android.os.Messenger

Here are the examples of the java api class android.os.Messenger taken from open source projects.

1. MusicActivity#setupMusicAdapters()

Project: serenity-android
File: MusicActivity.java
protected void setupMusicAdapters() {
    categoryHandler = new CategoryHandler();
    Messenger messenger = new Messenger(categoryHandler);
    Intent categoriesIntent = new Intent(this, CategoryRetrievalIntentService.class);
    categoriesIntent.putExtra("key", key);
    categoriesIntent.putExtra("filterAlbums", true);
    categoriesIntent.putExtra("MESSENGER", messenger);
    startService(categoriesIntent);
    context = this;
}

2. ViewKeyAdvUserIdsFragment#addUserId()

Project: open-keychain
File: ViewKeyAdvUserIdsFragment.java
private void addUserId() {
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            if (message.what == SetPassphraseDialogFragment.MESSAGE_OKAY) {
                Bundle data = message.getData();
                // add new user id
                mUserIdsAddedAdapter.add(data.getString(AddUserIdDialogFragment.MESSAGE_DATA_USER_ID));
            }
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(returnHandler);
    // pre-fill out primary name
    AddUserIdDialogFragment addUserIdDialog = AddUserIdDialogFragment.newInstance(messenger, "", true);
    addUserIdDialog.show(getActivity().getSupportFragmentManager(), "addUserIdDialog");
}

3. EditKeyFragment#addUserId()

Project: open-keychain
File: EditKeyFragment.java
private void addUserId() {
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            if (message.what == SetPassphraseDialogFragment.MESSAGE_OKAY) {
                Bundle data = message.getData();
                // add new user id
                mUserIdsAddedAdapter.add(data.getString(AddUserIdDialogFragment.MESSAGE_DATA_USER_ID));
            }
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(returnHandler);
    // pre-fill out primary name
    String predefinedName = KeyRing.splitUserId(mPrimaryUserId).name;
    AddUserIdDialogFragment addUserIdDialog = AddUserIdDialogFragment.newInstance(messenger, predefinedName, true);
    addUserIdDialog.show(getActivity().getSupportFragmentManager(), "addUserIdDialog");
}

4. EditIdentitiesFragment#addUserId()

Project: open-keychain
File: EditIdentitiesFragment.java
private void addUserId() {
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            if (message.what == SetPassphraseDialogFragment.MESSAGE_OKAY) {
                Bundle data = message.getData();
                // add new user id
                mUserIdsAddedAdapter.add(data.getString(AddUserIdDialogFragment.MESSAGE_DATA_USER_ID));
            }
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(returnHandler);
    // pre-fill out primary name
    String predefinedName = KeyRing.splitUserId(mPrimaryUserId).name;
    AddUserIdDialogFragment addUserIdDialog = AddUserIdDialogFragment.newInstance(messenger, predefinedName, false);
    addUserIdDialog.show(getActivity().getSupportFragmentManager(), "addUserIdDialog");
}

5. CreateKeyEmailFragment#addEmail()

Project: open-keychain
File: CreateKeyEmailFragment.java
/**
     * Displays a dialog fragment for the user to input a valid email.
     */
private void addEmail() {
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            if (message.what == AddEmailDialogFragment.MESSAGE_OKAY) {
                Bundle data = message.getData();
                String email = data.getString(AddEmailDialogFragment.MESSAGE_DATA_EMAIL);
                if (checkEmail(email, true)) {
                    // add new user id
                    mEmailAdapter.add(email);
                }
            }
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(returnHandler);
    AddEmailDialogFragment addEmailDialog = AddEmailDialogFragment.newInstance(messenger);
    addEmailDialog.show(getActivity().getSupportFragmentManager(), "addEmailDialog");
}

6. NetworkLog#doBindService()

Project: networklog
File: NetworkLog.java
void doBindService() {
    MyLog.d("doBindService");
    if (isBound) {
        MyLog.d("Already bound to service; unbinding...");
        doUnbindService();
    }
    messenger = new Messenger(new IncomingHandler());
    MyLog.d("Created messenger: " + messenger);
    MyLog.d("Binding connection to service: " + connection);
    bindService(new Intent(this, NetworkLogService.class), connection, 0);
    MyLog.d("doBindService done");
}

7. OpenPgpApi#executeApiAsync()

Project: k-9
File: OpenPgpApi.java
public <T> CancelableBackgroundOperation executeApiAsync(Intent data, OpenPgpDataSource dataSource, OpenPgpDataSink<T> dataSink, final IOpenPgpSinkResultCallback<T> callback) {
    Messenger messenger = new Messenger(new Handler(new Handler.Callback() {

        @Override
        public boolean handleMessage(Message message) {
            callback.onProgress(message.arg1, message.arg2);
            return true;
        }
    }));
    data.putExtra(EXTRA_PROGRESS_MESSENGER, messenger);
    OpenPgpSourceSinkAsyncTask<T> task = new OpenPgpSourceSinkAsyncTask<>(data, dataSource, dataSink, callback);
    // http://commonsware.com/blog/2012/04/20/asynctask-threading-regression-confirmed.html
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
        task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, (Void[]) null);
    } else {
        task.execute((Void[]) null);
    }
    return task;
}

8. TestJobService#onStartCommand()

Project: JobSchedulerCompat
File: TestJobService.java
/**
     * When the app's MainActivity is created, it starts this service. This is so that the activity
     * and this service can communicate back and forth. See "setUiCalback()"
     */
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    Messenger callback = intent.getParcelableExtra("messenger");
    Message m = Message.obtain();
    m.what = MainActivity.MSG_SERVICE_OBJ;
    m.obj = this;
    try {
        callback.send(m);
    } catch (RemoteException e) {
        Log.e(TAG, "Error passing service object back to activity.");
    }
    return START_NOT_STICKY;
}

9. ServiceBinder#onServiceConnected()

Project: dmix
File: ServiceBinder.java
/**
     * The ServiceConnection callback called when a connection to the Service has been established.
     *
     * @param name    The component name of the service that has been connected.
     * @param service The communication channel to the service.
     */
@Override
public final void onServiceConnected(final ComponentName name, final IBinder service) {
    mServiceMessenger = new Messenger(service);
    if (!mIsPersistent) {
        setupDisconnectionDelay();
    }
    mClientHandler.sendEmptyMessage(CONNECTED);
    /** Register with the service. */
    sendMessageToService(REGISTER_CLIENT);
    if (mMessageOnConnection != null) {
        sendMessageToService(mMessageOnConnection);
        mMessageOnConnection = null;
    }
    if (DEBUG) {
        Log.d(TAG, "Attached.");
    }
}

10. MainActivity#onResume()

Project: codeexamples-android
File: MainActivity.java
protected void onResume() {
    super.onResume();
    Toast.makeText(this, "OnResume called", Toast.LENGTH_SHORT).show();
    Intent intent = null;
    intent = new Intent(this, DownloadServiceMessenger.class);
    // Create a new Messenger for the communication back
    // From the Service to the Activity
    Messenger messenger = new Messenger(handler);
    intent.putExtra("MESSENGER", messenger);
    bindService(intent, conn, Context.BIND_AUTO_CREATE);
}

11. ViewKeyActivity#deleteKey()

Project: apg
File: ViewKeyActivity.java
private void deleteKey() {
    // Message is received after key is deleted
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            if (message.arg1 == MessageStatus.OKAY.ordinal()) {
                setResult(RESULT_CANCELED);
                finish();
            }
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(returnHandler);
    DeleteKeyDialogFragment deleteKeyDialog = DeleteKeyDialogFragment.newInstance(messenger, new long[] { mMasterKeyId });
    deleteKeyDialog.show(getSupportFragmentManager(), "deleteKeyDialog");
}

12. ViewKeyActivity#startCertifyIntent()

Project: apg
File: ViewKeyActivity.java
private void startCertifyIntent(Intent intent) {
    // Message is received after signing 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()) {
                Bundle data = message.getData();
                CertifyResult result = data.getParcelable(CertifyResult.EXTRA_RESULT);
                result.createNotify(ViewKeyActivity.this).show();
            }
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(saveHandler);
    intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger);
    startActivityForResult(intent, 0);
}

13. EditKeyFragment#addUserId()

Project: apg
File: EditKeyFragment.java
private void addUserId() {
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            if (message.what == SetPassphraseDialogFragment.MESSAGE_OKAY) {
                Bundle data = message.getData();
                // add new user id
                mUserIdsAddedAdapter.add(data.getString(AddUserIdDialogFragment.MESSAGE_DATA_USER_ID));
            }
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(returnHandler);
    // pre-fill out primary name
    String predefinedName = KeyRing.splitUserId(mPrimaryUserId).name;
    AddUserIdDialogFragment addUserIdDialog = AddUserIdDialogFragment.newInstance(messenger, predefinedName);
    addUserIdDialog.show(getActivity().getSupportFragmentManager(), "addUserIdDialog");
}

14. CreateKeyEmailFragment#addEmail()

Project: apg
File: CreateKeyEmailFragment.java
/**
     * Displays a dialog fragment for the user to input a valid email.
     */
private void addEmail() {
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            if (message.what == SetPassphraseDialogFragment.MESSAGE_OKAY) {
                Bundle data = message.getData();
                String email = data.getString(AddEmailDialogFragment.MESSAGE_DATA_EMAIL);
                if (checkEmail(email, true)) {
                    // add new user id
                    mEmailAdapter.add(email);
                }
            }
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(returnHandler);
    AddEmailDialogFragment addEmailDialog = AddEmailDialogFragment.newInstance(messenger);
    addEmailDialog.show(getActivity().getSupportFragmentManager(), "addEmailDialog");
}

15. WifiManager#initialize()

Project: android-proxy
File: WifiManager.java
/**
     * Registers the application with the Wi-Fi framework. This function
     * must be the first to be called before any Wi-Fi operations are performed.
     *
     * @param srcContext is the context of the source
     * @param srcLooper is the Looper on which the callbacks are receivied
     * @param listener for callback at loss of framework communication. Can be null.
     * @return Channel instance that is necessary for performing any further Wi-Fi operations.
     *         A null is returned upon failure to initialize.
     * @hide
     */
public Channel initialize(Context srcContext, Looper srcLooper, ChannelListener listener) {
    Messenger messenger = getWifiServiceMessenger();
    if (messenger == null)
        return null;
    Channel c = new Channel(srcLooper, listener);
    if (c.mAsyncChannel.connectSync(srcContext, c.mHandler, messenger) == AsyncChannel.STATUS_SUCCESSFUL) {
        return c;
    } else {
        return null;
    }
}

16. MPDroidService#onBind()

Project: dmix
File: MPDroidService.java
/**
     * Binds to the incoming client.
     *
     * @param intent Intent used to bind to the service.
     * @return A messenger for the incoming client.
     */
@Override
public IBinder onBind(final Intent intent) {
    /** Target we publish for clients to send messages to IncomingHandler. */
    final Messenger serviceMessenger = new Messenger(mHandler);
    return serviceMessenger.getBinder();
}

17. ViewKeyAdvSubkeysFragment#editSubkey()

Project: open-keychain
File: ViewKeyAdvSubkeysFragment.java
private void editSubkey(final int position) {
    final long keyId = mSubkeysAdapter.getKeyId(position);
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            switch(message.what) {
                case EditSubkeyDialogFragment.MESSAGE_CHANGE_EXPIRY:
                    editSubkeyExpiry(position);
                    break;
                case EditSubkeyDialogFragment.MESSAGE_REVOKE:
                    // toggle
                    if (mEditModeSaveKeyringParcel.mRevokeSubKeys.contains(keyId)) {
                        mEditModeSaveKeyringParcel.mRevokeSubKeys.remove(keyId);
                    } else {
                        mEditModeSaveKeyringParcel.mRevokeSubKeys.add(keyId);
                    }
                    break;
                case EditSubkeyDialogFragment.MESSAGE_STRIP:
                    {
                        SecretKeyType secretKeyType = mSubkeysAdapter.getSecretKeyType(position);
                        if (secretKeyType == SecretKeyType.GNU_DUMMY) {
                            // Key is already stripped; this is a no-op.
                            break;
                        }
                        SubkeyChange change = mEditModeSaveKeyringParcel.getSubkeyChange(keyId);
                        if (change == null) {
                            mEditModeSaveKeyringParcel.mChangeSubKeys.add(new SubkeyChange(keyId, true, false));
                            break;
                        }
                        // toggle
                        change.mDummyStrip = !change.mDummyStrip;
                        if (change.mDummyStrip && change.mMoveKeyToSecurityToken) {
                            // User had chosen to divert key, but now wants to strip it instead.
                            change.mMoveKeyToSecurityToken = false;
                        }
                        break;
                    }
                case EditSubkeyDialogFragment.MESSAGE_MOVE_KEY_TO_SECURITY_TOKEN:
                    {
                        SecretKeyType secretKeyType = mSubkeysAdapter.getSecretKeyType(position);
                        if (secretKeyType == SecretKeyType.DIVERT_TO_CARD || secretKeyType == SecretKeyType.GNU_DUMMY) {
                            Notify.create(getActivity(), R.string.edit_key_error_bad_security_token_stripped, Notify.Style.ERROR).show();
                            break;
                        }
                        int algorithm = mSubkeysAdapter.getAlgorithm(position);
                        if (algorithm != PublicKeyAlgorithmTags.RSA_GENERAL && algorithm != PublicKeyAlgorithmTags.RSA_ENCRYPT && algorithm != PublicKeyAlgorithmTags.RSA_SIGN) {
                            Notify.create(getActivity(), R.string.edit_key_error_bad_security_token_algo, Notify.Style.ERROR).show();
                            break;
                        }
                        if (mSubkeysAdapter.getKeySize(position) != 2048) {
                            Notify.create(getActivity(), R.string.edit_key_error_bad_security_token_size, Notify.Style.ERROR).show();
                            break;
                        }
                        SubkeyChange change;
                        change = mEditModeSaveKeyringParcel.getSubkeyChange(keyId);
                        if (change == null) {
                            mEditModeSaveKeyringParcel.mChangeSubKeys.add(new SubkeyChange(keyId, false, true));
                            break;
                        }
                        // toggle
                        change.mMoveKeyToSecurityToken = !change.mMoveKeyToSecurityToken;
                        if (change.mMoveKeyToSecurityToken && change.mDummyStrip) {
                            // User had chosen to strip key, but now wants to divert it.
                            change.mDummyStrip = false;
                        }
                        break;
                    }
            }
            getLoaderManager().getLoader(LOADER_ID_SUBKEYS).forceLoad();
        }
    };
    // Create a new Messenger for the communication back
    final Messenger messenger = new Messenger(returnHandler);
    DialogFragmentWorkaround.INTERFACE.runnableRunDelayed(new Runnable() {

        public void run() {
            EditSubkeyDialogFragment dialogFragment = EditSubkeyDialogFragment.newInstance(messenger);
            dialogFragment.show(getActivity().getSupportFragmentManager(), "editSubkeyDialog");
        }
    });
}

18. ViewKeyActivity#changePassword()

Project: open-keychain
File: ViewKeyActivity.java
private void changePassword() {
    CryptoOperationHelper.Callback<ChangeUnlockParcel, EditKeyResult> editKeyCallback = new CryptoOperationHelper.Callback<ChangeUnlockParcel, EditKeyResult>() {

        @Override
        public ChangeUnlockParcel createOperationInput() {
            return mChangeUnlockParcel;
        }

        @Override
        public void onCryptoOperationSuccess(EditKeyResult result) {
            displayResult(result);
        }

        @Override
        public void onCryptoOperationCancelled() {
        }

        @Override
        public void onCryptoOperationError(EditKeyResult result) {
            displayResult(result);
        }

        @Override
        public boolean onCryptoSetProgress(String msg, int progress, int max) {
            return false;
        }
    };
    mEditOpHelper = new CryptoOperationHelper<>(2, this, editKeyCallback, R.string.progress_building_key);
    // Message is received after passphrase is cached
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            if (message.what == SetPassphraseDialogFragment.MESSAGE_OKAY) {
                Bundle data = message.getData();
                // use new passphrase!
                mChangeUnlockParcel = new ChangeUnlockParcel(mMasterKeyId, mFingerprint, (Passphrase) data.getParcelable(SetPassphraseDialogFragment.MESSAGE_NEW_PASSPHRASE));
                mEditOpHelper.cryptoOperation();
            }
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(returnHandler);
    SetPassphraseDialogFragment setPassphraseDialog = SetPassphraseDialogFragment.newInstance(messenger, R.string.title_change_passphrase);
    setPassphraseDialog.show(getSupportFragmentManager(), "setPassphraseDialog");
}

19. InstallDialogFragmentHelper#getInstallDialogFromArgs()

Project: open-keychain
File: InstallDialogFragmentHelper.java
public static AlertDialog getInstallDialogFromArgs(Bundle args, final Activity activity, final int messengerMiddleButtonClicked, final int messengerDialogDimissed) {
    final Messenger messenger = args.getParcelable(ARG_MESSENGER);
    final int title = args.getInt(ARG_TITLE);
    final int message = args.getInt(ARG_MESSAGE);
    final int middleButton = args.getInt(ARG_MIDDLE_BUTTON);
    final String installPath = args.getString(ARG_INSTALL_PATH);
    final boolean useMiddleButton = args.getBoolean(ARG_USE_MIDDLE_BUTTON);
    ContextThemeWrapper theme = ThemeChanger.getDialogThemeWrapper(activity);
    CustomAlertDialogBuilder builder = new CustomAlertDialogBuilder(theme);
    builder.setTitle(title).setMessage(message);
    builder.setNegativeButton(R.string.orbot_install_dialog_cancel, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            Message msg = Message.obtain();
            msg.what = messengerDialogDimissed;
            try {
                messenger.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);
            }
        }
    });
    builder.setPositiveButton(R.string.orbot_install_dialog_install, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            Uri uri = Uri.parse(installPath);
            Intent intent = new Intent(Intent.ACTION_VIEW, uri);
            activity.startActivity(intent);
            Message msg = Message.obtain();
            msg.what = messengerDialogDimissed;
            try {
                messenger.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);
            }
        }
    });
    if (useMiddleButton) {
        builder.setNeutralButton(middleButton, new DialogInterface.OnClickListener() {

            @Override
            public void onClick(DialogInterface dialog, int which) {
                Message msg = Message.obtain();
                msg.what = messengerMiddleButtonClicked;
                try {
                    messenger.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);
                }
            }
        });
    }
    return builder.show();
}

20. SettingsKeyserverFragment#startEditKeyserverDialog()

Project: open-keychain
File: SettingsKeyserverFragment.java
private void startEditKeyserverDialog(AddEditKeyserverDialogFragment.DialogAction action, String keyserver, final int position) {
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            Bundle data = message.getData();
            switch(message.what) {
                case AddEditKeyserverDialogFragment.MESSAGE_OKAY:
                    {
                        boolean deleted = data.getBoolean(AddEditKeyserverDialogFragment.MESSAGE_KEYSERVER_DELETED, false);
                        if (deleted) {
                            Notify.create(getActivity(), getActivity().getString(R.string.keyserver_preference_deleted, mKeyservers.get(position)), Notify.Style.OK).show();
                            deleteKeyserver(position);
                            return;
                        }
                        boolean verified = data.getBoolean(AddEditKeyserverDialogFragment.MESSAGE_VERIFIED);
                        if (verified) {
                            Notify.create(getActivity(), R.string.add_keyserver_connection_verified, Notify.Style.OK).show();
                        } else {
                            Notify.create(getActivity(), R.string.add_keyserver_without_verification, Notify.Style.WARN).show();
                        }
                        String keyserver = data.getString(AddEditKeyserverDialogFragment.MESSAGE_KEYSERVER);
                        AddEditKeyserverDialogFragment.DialogAction dialogAction = (AddEditKeyserverDialogFragment.DialogAction) data.getSerializable(AddEditKeyserverDialogFragment.MESSAGE_DIALOG_ACTION);
                        switch(dialogAction) {
                            case ADD:
                                addKeyserver(keyserver);
                                break;
                            case EDIT:
                                editKeyserver(keyserver, position);
                                break;
                        }
                        break;
                    }
            }
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(returnHandler);
    AddEditKeyserverDialogFragment dialogFragment = AddEditKeyserverDialogFragment.newInstance(messenger, action, keyserver, position);
    dialogFragment.show(getFragmentManager(), "addKeyserverDialog");
}

21. EditKeyFragment#editSubkeyExpiry()

Project: open-keychain
File: EditKeyFragment.java
private void editSubkeyExpiry(final int position) {
    final long keyId = mSubkeysAdapter.getKeyId(position);
    final Long creationDate = mSubkeysAdapter.getCreationDate(position);
    final Long expiryDate = mSubkeysAdapter.getExpiryDate(position);
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            switch(message.what) {
                case EditSubkeyExpiryDialogFragment.MESSAGE_NEW_EXPIRY:
                    mSaveKeyringParcel.getOrCreateSubkeyChange(keyId).mExpiry = (Long) message.getData().getSerializable(EditSubkeyExpiryDialogFragment.MESSAGE_DATA_EXPIRY);
                    break;
            }
            getLoaderManager().getLoader(LOADER_ID_SUBKEYS).forceLoad();
        }
    };
    // Create a new Messenger for the communication back
    final Messenger messenger = new Messenger(returnHandler);
    DialogFragmentWorkaround.INTERFACE.runnableRunDelayed(new Runnable() {

        public void run() {
            EditSubkeyExpiryDialogFragment dialogFragment = EditSubkeyExpiryDialogFragment.newInstance(messenger, creationDate, expiryDate);
            dialogFragment.show(getActivity().getSupportFragmentManager(), "editSubkeyExpiryDialog");
        }
    });
}

22. EditKeyFragment#editSubkey()

Project: open-keychain
File: EditKeyFragment.java
private void editSubkey(final int position) {
    final long keyId = mSubkeysAdapter.getKeyId(position);
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            switch(message.what) {
                case EditSubkeyDialogFragment.MESSAGE_CHANGE_EXPIRY:
                    editSubkeyExpiry(position);
                    break;
                case EditSubkeyDialogFragment.MESSAGE_REVOKE:
                    // toggle
                    if (mSaveKeyringParcel.mRevokeSubKeys.contains(keyId)) {
                        mSaveKeyringParcel.mRevokeSubKeys.remove(keyId);
                    } else {
                        mSaveKeyringParcel.mRevokeSubKeys.add(keyId);
                    }
                    break;
                case EditSubkeyDialogFragment.MESSAGE_STRIP:
                    {
                        SecretKeyType secretKeyType = mSubkeysAdapter.getSecretKeyType(position);
                        if (secretKeyType == SecretKeyType.GNU_DUMMY) {
                            // Key is already stripped; this is a no-op.
                            break;
                        }
                        SubkeyChange change = mSaveKeyringParcel.getSubkeyChange(keyId);
                        if (change == null) {
                            mSaveKeyringParcel.mChangeSubKeys.add(new SubkeyChange(keyId, true, false));
                            break;
                        }
                        // toggle
                        change.mDummyStrip = !change.mDummyStrip;
                        if (change.mDummyStrip && change.mMoveKeyToSecurityToken) {
                            // User had chosen to divert key, but now wants to strip it instead.
                            change.mMoveKeyToSecurityToken = false;
                        }
                        break;
                    }
                case EditSubkeyDialogFragment.MESSAGE_MOVE_KEY_TO_SECURITY_TOKEN:
                    {
                        SecretKeyType secretKeyType = mSubkeysAdapter.getSecretKeyType(position);
                        if (secretKeyType == SecretKeyType.DIVERT_TO_CARD || secretKeyType == SecretKeyType.GNU_DUMMY) {
                            Notify.create(getActivity(), R.string.edit_key_error_bad_security_token_stripped, Notify.Style.ERROR).show();
                            break;
                        }
                        int algorithm = mSubkeysAdapter.getAlgorithm(position);
                        if (algorithm != PublicKeyAlgorithmTags.RSA_GENERAL && algorithm != PublicKeyAlgorithmTags.RSA_ENCRYPT && algorithm != PublicKeyAlgorithmTags.RSA_SIGN) {
                            Notify.create(getActivity(), R.string.edit_key_error_bad_security_token_algo, Notify.Style.ERROR).show();
                            break;
                        }
                        if (mSubkeysAdapter.getKeySize(position) != 2048) {
                            Notify.create(getActivity(), R.string.edit_key_error_bad_security_token_size, Notify.Style.ERROR).show();
                            break;
                        }
                        SubkeyChange change;
                        change = mSaveKeyringParcel.getSubkeyChange(keyId);
                        if (change == null) {
                            mSaveKeyringParcel.mChangeSubKeys.add(new SubkeyChange(keyId, false, true));
                            break;
                        }
                        // toggle
                        change.mMoveKeyToSecurityToken = !change.mMoveKeyToSecurityToken;
                        if (change.mMoveKeyToSecurityToken && change.mDummyStrip) {
                            // User had chosen to strip key, but now wants to divert it.
                            change.mDummyStrip = false;
                        }
                        break;
                    }
            }
            getLoaderManager().getLoader(LOADER_ID_SUBKEYS).forceLoad();
        }
    };
    // Create a new Messenger for the communication back
    final Messenger messenger = new Messenger(returnHandler);
    DialogFragmentWorkaround.INTERFACE.runnableRunDelayed(new Runnable() {

        public void run() {
            EditSubkeyDialogFragment dialogFragment = EditSubkeyDialogFragment.newInstance(messenger);
            dialogFragment.show(getActivity().getSupportFragmentManager(), "editSubkeyDialog");
        }
    });
}

23. EditKeyFragment#editUserId()

Project: open-keychain
File: EditKeyFragment.java
private void editUserId(final int position) {
    final String userId = mUserIdsAdapter.getUserId(position);
    final boolean isRevoked = mUserIdsAdapter.getIsRevoked(position);
    final boolean isRevokedPending = mUserIdsAdapter.getIsRevokedPending(position);
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            switch(message.what) {
                case EditUserIdDialogFragment.MESSAGE_CHANGE_PRIMARY_USER_ID:
                    // toggle
                    if (mSaveKeyringParcel.mChangePrimaryUserId != null && mSaveKeyringParcel.mChangePrimaryUserId.equals(userId)) {
                        mSaveKeyringParcel.mChangePrimaryUserId = null;
                    } else {
                        mSaveKeyringParcel.mChangePrimaryUserId = userId;
                    }
                    break;
                case EditUserIdDialogFragment.MESSAGE_REVOKE:
                    // toggle
                    if (mSaveKeyringParcel.mRevokeUserIds.contains(userId)) {
                        mSaveKeyringParcel.mRevokeUserIds.remove(userId);
                    } else {
                        mSaveKeyringParcel.mRevokeUserIds.add(userId);
                        // not possible to revoke and change to primary user id
                        if (mSaveKeyringParcel.mChangePrimaryUserId != null && mSaveKeyringParcel.mChangePrimaryUserId.equals(userId)) {
                            mSaveKeyringParcel.mChangePrimaryUserId = null;
                        }
                    }
                    break;
            }
            getLoaderManager().getLoader(LOADER_ID_USER_IDS).forceLoad();
        }
    };
    // Create a new Messenger for the communication back
    final Messenger messenger = new Messenger(returnHandler);
    DialogFragmentWorkaround.INTERFACE.runnableRunDelayed(new Runnable() {

        public void run() {
            EditUserIdDialogFragment dialogFragment = EditUserIdDialogFragment.newInstance(messenger, isRevoked, isRevokedPending);
            dialogFragment.show(getActivity().getSupportFragmentManager(), "editUserIdDialog");
        }
    });
}

24. EditKeyFragment#changePassphrase()

Project: open-keychain
File: EditKeyFragment.java
private void changePassphrase() {
    //        Intent passIntent = new Intent(getActivity(), PassphraseWizardActivity.class);
    //        passIntent.setAction(PassphraseWizardActivity.CREATE_METHOD);
    //        startActivityForResult(passIntent, 12);
    // Message is received after passphrase is cached
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            if (message.what == SetPassphraseDialogFragment.MESSAGE_OKAY) {
                Bundle data = message.getData();
                // cache new returned passphrase!
                mSaveKeyringParcel.setNewUnlock(new ChangeUnlockParcel((Passphrase) data.getParcelable(SetPassphraseDialogFragment.MESSAGE_NEW_PASSPHRASE)));
            }
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(returnHandler);
    SetPassphraseDialogFragment setPassphraseDialog = SetPassphraseDialogFragment.newInstance(messenger, R.string.title_change_passphrase);
    setPassphraseDialog.show(getActivity().getSupportFragmentManager(), "setPassphraseDialog");
}

25. EditIdentitiesFragment#editUserId()

Project: open-keychain
File: EditIdentitiesFragment.java
private void editUserId(final int position) {
    final String userId = mUserIdsAdapter.getUserId(position);
    final boolean isRevoked = mUserIdsAdapter.getIsRevoked(position);
    final boolean isRevokedPending = mUserIdsAdapter.getIsRevokedPending(position);
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            switch(message.what) {
                case EditUserIdDialogFragment.MESSAGE_CHANGE_PRIMARY_USER_ID:
                    // toggle
                    if (mSaveKeyringParcel.mChangePrimaryUserId != null && mSaveKeyringParcel.mChangePrimaryUserId.equals(userId)) {
                        mSaveKeyringParcel.mChangePrimaryUserId = null;
                    } else {
                        mSaveKeyringParcel.mChangePrimaryUserId = userId;
                    }
                    break;
                case EditUserIdDialogFragment.MESSAGE_REVOKE:
                    // toggle
                    if (mSaveKeyringParcel.mRevokeUserIds.contains(userId)) {
                        mSaveKeyringParcel.mRevokeUserIds.remove(userId);
                    } else {
                        mSaveKeyringParcel.mRevokeUserIds.add(userId);
                        // not possible to revoke and change to primary user id
                        if (mSaveKeyringParcel.mChangePrimaryUserId != null && mSaveKeyringParcel.mChangePrimaryUserId.equals(userId)) {
                            mSaveKeyringParcel.mChangePrimaryUserId = null;
                        }
                    }
                    break;
            }
            getLoaderManager().getLoader(LOADER_ID_USER_IDS).forceLoad();
        }
    };
    // Create a new Messenger for the communication back
    final Messenger messenger = new Messenger(returnHandler);
    DialogFragmentWorkaround.INTERFACE.runnableRunDelayed(new Runnable() {

        public void run() {
            EditUserIdDialogFragment dialogFragment = EditUserIdDialogFragment.newInstance(messenger, isRevoked, isRevokedPending);
            dialogFragment.show(getActivity().getSupportFragmentManager(), "editUserIdDialog");
        }
    });
}

26. OrbotStartDialogFragment#onCreateDialog()

Project: open-keychain
File: OrbotStartDialogFragment.java
@NonNull
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    final Messenger messenger = getArguments().getParcelable(ARG_MESSENGER);
    int title = getArguments().getInt(ARG_TITLE);
    final int message = getArguments().getInt(ARG_MESSAGE);
    int middleButton = getArguments().getInt(ARG_MIDDLE_BUTTON);
    final Activity activity = getActivity();
    ContextThemeWrapper theme = ThemeChanger.getDialogThemeWrapper(activity);
    CustomAlertDialogBuilder builder = new CustomAlertDialogBuilder(theme);
    builder.setTitle(title).setMessage(message);
    builder.setNegativeButton(R.string.orbot_start_dialog_cancel, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            Message msg = Message.obtain();
            msg.what = MESSAGE_DIALOG_CANCELLED;
            try {
                messenger.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);
            }
        }
    });
    builder.setNeutralButton(middleButton, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            Message msg = new Message();
            msg.what = MESSAGE_MIDDLE_BUTTON;
            try {
                messenger.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);
            }
        }
    });
    builder.setPositiveButton(R.string.orbot_start_dialog_start, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
        // actual onClick defined in onStart, this is just to make the button appear
        }
    });
    return builder.show();
}

27. CryptoOperationHelper#cryptoOperation()

Project: open-keychain
File: CryptoOperationHelper.java
public void cryptoOperation(final CryptoInputParcel cryptoInput) {
    FragmentActivity activity = mUseFragment ? mFragment.getActivity() : mActivity;
    T operationInput = mCallback.createOperationInput();
    if (operationInput == null) {
        return;
    }
    // Send all information needed to service to edit key in other thread
    Intent intent = new Intent(activity, KeychainService.class);
    intent.putExtra(KeychainService.EXTRA_OPERATION_INPUT, operationInput);
    intent.putExtra(KeychainService.EXTRA_CRYPTO_INPUT, cryptoInput);
    ServiceProgressHandler saveHandler = new ServiceProgressHandler(activity) {

        @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);
            }
        }

        @Override
        protected void onSetProgress(String msg, int progress, int max) {
            // allow handling of progress in fragment, or delegate upwards
            if (!mCallback.onCryptoSetProgress(msg, progress, max)) {
                super.onSetProgress(msg, progress, max);
            }
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(saveHandler);
    intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger);
    if (mProgressMessageResource != null) {
        saveHandler.showProgressDialog(activity.getString(mProgressMessageResource), ProgressDialog.STYLE_HORIZONTAL, mCancellable);
    }
    activity.startService(intent);
}

28. PassphraseCacheService#getCachedPassphrase()

Project: open-keychain
File: PassphraseCacheService.java
/**
     * Gets a cached passphrase from memory by sending an intent to the service. This method is
     * designed to wait until the service returns the passphrase.
     *
     * @return passphrase or null (if no passphrase is cached for this keyId)
     */
public static Passphrase getCachedPassphrase(Context context, long masterKeyId, long subKeyId) throws KeyNotFoundException {
    Log.d(Constants.TAG, "PassphraseCacheService.getCachedPassphrase() for masterKeyId " + masterKeyId + ", subKeyId " + subKeyId);
    Intent intent = new Intent(context, PassphraseCacheService.class);
    intent.setAction(ACTION_PASSPHRASE_CACHE_GET);
    final Object mutex = new Object();
    final Message returnMessage = Message.obtain();
    HandlerThread handlerThread = new HandlerThread("getPassphraseThread");
    handlerThread.start();
    Handler returnHandler = new Handler(handlerThread.getLooper()) {

        @Override
        public void handleMessage(Message message) {
            // copy over result to handle after mutex.wait
            returnMessage.what = message.what;
            returnMessage.copyFrom(message);
            synchronized (mutex) {
                mutex.notify();
            }
            // quit handlerThread
            getLooper().quit();
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(returnHandler);
    intent.putExtra(EXTRA_KEY_ID, masterKeyId);
    intent.putExtra(EXTRA_SUBKEY_ID, subKeyId);
    intent.putExtra(EXTRA_MESSENGER, messenger);
    // send intent to this service
    context.startService(intent);
    // noinspection SynchronizationOnLocalVariableOrMethodParameter
    synchronized (mutex) {
        try {
            mutex.wait(3000);
        } catch (InterruptedException e) {
        }
    }
    switch(returnMessage.what) {
        case MSG_PASSPHRASE_CACHE_GET_OKAY:
            Bundle returnData = returnMessage.getData();
            returnData.setClassLoader(context.getClassLoader());
            return returnData.getParcelable(EXTRA_PASSPHRASE);
        case MSG_PASSPHRASE_CACHE_GET_KEY_NOT_FOUND:
            throw new KeyNotFoundException();
        default:
            Log.e(Constants.TAG, "timeout case!");
            throw new KeyNotFoundException("should not happen!");
    }
}

29. CryptoInputParcelCacheService#getCryptoInputParcel()

Project: open-keychain
File: CryptoInputParcelCacheService.java
private static CryptoInputParcel getCryptoInputParcel(Context context, UUID uuid) throws InputParcelNotFound {
    Intent intent = new Intent(context, CryptoInputParcelCacheService.class);
    intent.setAction(ACTION_GET);
    final Object mutex = new Object();
    final Message returnMessage = Message.obtain();
    HandlerThread handlerThread = new HandlerThread("getParcelableThread");
    handlerThread.start();
    Handler returnHandler = new Handler(handlerThread.getLooper()) {

        @Override
        public void handleMessage(Message message) {
            // copy over result to handle after mutex.wait
            returnMessage.what = message.what;
            returnMessage.copyFrom(message);
            synchronized (mutex) {
                mutex.notify();
            }
            // quit handlerThread
            getLooper().quit();
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(returnHandler);
    intent.putExtra(EXTRA_UUID1, uuid.getMostSignificantBits());
    intent.putExtra(EXTRA_UUID2, uuid.getLeastSignificantBits());
    intent.putExtra(EXTRA_MESSENGER, messenger);
    // send intent to this service
    context.startService(intent);
    // noinspection SynchronizationOnLocalVariableOrMethodParameter
    synchronized (mutex) {
        try {
            mutex.wait(3000);
        } catch (InterruptedException e) {
        }
    }
    switch(returnMessage.what) {
        case MSG_GET_OKAY:
            Bundle returnData = returnMessage.getData();
            returnData.setClassLoader(context.getClassLoader());
            return returnData.getParcelable(EXTRA_CRYPTO_INPUT_PARCEL);
        case MSG_GET_NOT_FOUND:
            throw new InputParcelNotFound();
        default:
            Log.e(Constants.TAG, "timeout!");
            throw new InputParcelNotFound("should not happen!");
    }
}

30. SignFileActivity#onCreate()

Project: gnupg-for-android
File: SignFileActivity.java
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mFragmentManager = getSupportFragmentManager();
    getSupportActionBar().setDisplayHomeAsUpEnabled(true);
    // Create a new Messenger for the communication back
    // Message is received after file is selected
    mMessenger = new Messenger(new Handler() {

        @Override
        public void handleMessage(Message message) {
            if (message.what == FileDialogFragment.MESSAGE_CANCELED) {
                cancel();
            } else if (message.what == FileDialogFragment.MESSAGE_OK) {
                processFile(message);
            } else if (message.what == Gpg2TaskFragment.GPG2_TASK_FINISHED) {
                sendSignedFile();
            }
        }
    });
    Intent intent = getIntent();
    Uri uri = intent.getData();
    Log.v(TAG, "onCreate: " + uri);
    String scheme = null;
    if (uri != null)
        scheme = uri.getScheme();
    if (scheme != null && scheme.equals("file") && new File(uri.getPath()).canRead())
        mDefaultFilename = uri.getPath();
    else
        mDefaultFilename = null;
    // set signing key to first/default secret key on device
    GnuPGKey key = null;
    GnuPGKey keys[] = GnuPG.context.listSecretKeys();
    if (keys != null && keys.length > 0) {
        key = keys[0];
    } else {
        showError(R.string.error_no_secret_key);
        return;
    }
    mSigningKeyFingerprint = key.getFingerprint();
    String text = getString(R.string.no_key_specified_using_this_key);
    text += String.format(" %s <%s> (%s) %s", key.getName(), key.getEmail(), key.getComment(), key.getFingerprint());
    Toast.makeText(this, text, Toast.LENGTH_LONG).show();
    showSignFileDialog();
}

31. ReceiveKeyActivity#onCreate()

Project: gnupg-for-android
File: ReceiveKeyActivity.java
@Override
@SuppressLint("DefaultLocale")
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    Intent intent = getIntent();
    // scheme should only ever be pure ASCII:
    String scheme = intent.getScheme().toLowerCase(Locale.ENGLISH);
    Uri uri = intent.getData();
    mFragmentManager = getSupportFragmentManager();
    // Message is received after the fingerprints are selected
    mReturnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            if (message.what == FileDialogFragment.MESSAGE_CANCELED) {
                cancel();
            } else if (message.what == FileDialogFragment.MESSAGE_OK) {
                Bundle data = message.getData();
                String fingerprints = data.getString(FileDialogFragment.MESSAGE_DATA_FILENAME);
                Log.d(TAG, "fingerprints: " + fingerprints);
                runRecvKey(fingerprints, false);
            } else if (message.what == Gpg2TaskFragment.GPG2_TASK_FINISHED) {
                notifyRecvKeyComplete();
            }
        }
    };
    // Create a new Messenger for the communication back
    mMessenger = new Messenger(mReturnHandler);
    if (uri == null) {
        finish();
        return;
    }
    if (scheme.equals("openpgp4fpr")) {
        String fingerprint = uri.toString().split(":")[1];
        GnuPGKey key = null;
        // to download if they want
        if (fingerprint.length() < 16) {
            String msg = String.format(getString(R.string.error_fingerprint_too_short_format), fingerprint);
            Toast.makeText(this, msg, Toast.LENGTH_LONG).show();
        } else {
            try {
                key = GnuPG.context.getKeyByFingerprint(fingerprint);
            } catch (GnuPGException e) {
                e.printStackTrace();
            }
        }
        if (key == null)
            showReceiveKeyByFingerprintDialog(fingerprint);
        else {
            String msg = String.format(getString(R.string.key_already_exists_format), fingerprint);
            msg += String.format(" %s <%s> (%s)", key.getName(), key.getEmail(), key.getComment());
            Toast.makeText(this, msg, Toast.LENGTH_LONG).show();
            showKeyAfterRecvKey();
        }
    }
}

32. ImportFileActivity#onCreate()

Project: gnupg-for-android
File: ImportFileActivity.java
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    getSupportActionBar().setDisplayHomeAsUpEnabled(true);
    mFragmentManager = getSupportFragmentManager();
    mMimeTypeMap = MimeTypeMap.getSingleton();
    // Get intent, action and MIME type
    Intent intent = getIntent();
    String action = intent.getAction();
    String type = intent.getType();
    // Message is received after file is selected
    mReturnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            if (message.what == FileDialogFragment.MESSAGE_CANCELED) {
                cancel();
            } else if (message.what == FileDialogFragment.MESSAGE_OK) {
                Bundle data = message.getData();
                File f = new File(data.getString(FileDialogFragment.MESSAGE_DATA_FILENAME));
                boolean deleteAfterImport = data.getBoolean(FileDialogFragment.MESSAGE_DATA_CHECKED);
                Log.d(TAG, "importFilename: " + f);
                Log.d(TAG, "deleteAfterImport: " + deleteAfterImport);
                runImport(f, deleteAfterImport);
            } else if (message.what == Gpg2TaskFragment.GPG2_TASK_FINISHED) {
                if (mDeleteThisFileAfterImport != null)
                    mDeleteThisFileAfterImport.delete();
                notifyImportComplete();
            }
        }
    };
    // Create a new Messenger for the communication back
    mMessenger = new Messenger(mReturnHandler);
    if (Intent.ACTION_SEND.equals(action) && type != null) {
        if ("text/plain".equals(type)) {
            // Handle text being sent
            handleSendText(intent);
        } else {
            // Handle single image being sent
            handleSendBinary(intent);
        }
    } else if (Intent.ACTION_SEND_MULTIPLE.equals(action)) {
        handleSendMultipleBinaries(intent);
    } else {
        Uri uri = intent.getData();
        if (uri == null)
            showImportFromFileDialog("");
        else
            showImportFromFileDialog(uri.getPath());
    }
}

33. EncryptFileActivity#onCreate()

Project: gnupg-for-android
File: EncryptFileActivity.java
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mFragmentManager = getSupportFragmentManager();
    getSupportActionBar().setDisplayHomeAsUpEnabled(true);
    // Create a new Messenger for the communication back
    // Message is received after file is selected
    mMessenger = new Messenger(new Handler() {

        @Override
        public void handleMessage(Message message) {
            if (message.what == FileDialogFragment.MESSAGE_CANCELED) {
                cancel();
            } else if (message.what == FileDialogFragment.MESSAGE_OK) {
                processFile(message);
            } else if (message.what == Gpg2TaskFragment.GPG2_TASK_FINISHED) {
                sendEncryptedFile();
            } else if (message.what == SELECTED_RECIPIENTS) {
                showEncryptToFileDialog();
            }
        }
    });
    Intent intent = getIntent();
    Uri uri = intent.getData();
    String scheme = null;
    if (uri != null)
        scheme = uri.getScheme();
    if (scheme != null && scheme.equals("file") && new File(uri.getPath()).canRead())
        mDefaultFilename = uri.getPath();
    else
        mDefaultFilename = null;
    Bundle extras = intent.getExtras();
    if (extras != null) {
        mRecipientKeyIds = extras.getLongArray(Intent.EXTRA_UID);
        mRecipientEmails = extras.getStringArray(Intent.EXTRA_EMAIL);
    }
    if (mRecipientKeyIds == null || mRecipientKeyIds.length == 0) {
        Intent i = new Intent(this, SelectKeysActivity.class);
        i.setAction(Action.SELECT_PUBLIC_KEYS);
        startActivityForResult(i, ENCRYPT_FILE_TO);
    } else {
        showEncryptToFileDialog();
    }
}

34. DebugLogActivity#showExportToFileDialog()

Project: gnupg-for-android
File: DebugLogActivity.java
/**
     * Show dialog to choose a file to export keys to
     */
public void showExportToFileDialog(final String defaultFilename) {
    // Message is received after file is selected
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            if (message.what == FileDialogFragment.MESSAGE_OK) {
                Bundle data = message.getData();
                String exportFilename = new File(data.getString(FileDialogFragment.MESSAGE_DATA_FILENAME)).getAbsolutePath();
                boolean exportSecretKeys = data.getBoolean(FileDialogFragment.MESSAGE_DATA_CHECKED);
                Log.d(TAG, "exportFilename: " + exportFilename);
                Log.d(TAG, "exportSecretKeys: " + exportSecretKeys);
                command = NativeHelper.gpg2 + " --batch ";
                String extension = null;
                if (exportSecretKeys) {
                    command += " --export-secret-keys ";
                    extension = ".skr";
                } else {
                    command += " --export ";
                    extension = ".pkr";
                }
                // force the right file extension
                final int lastPeriodPos = exportFilename.lastIndexOf('.');
                final int lastSlashPos = exportFilename.lastIndexOf('/');
                if (lastPeriodPos == -1 || lastPeriodPos < lastSlashPos)
                    // if the name has no extension, just tack it on to the
                    // end
                    exportFilename += extension;
                else
                    exportFilename = exportFilename.substring(0, lastPeriodPos) + extension;
                final File exportFile = new File(exportFilename);
                if (exportFile.exists()) {
                    Calendar now = Calendar.getInstance();
                    File newPath = new File(exportFile + "." + String.valueOf(now.getTimeInMillis()));
                    exportFile.renameTo(newPath);
                    Toast.makeText(getBaseContext(), String.format(getString(R.string.renamed_existing_file_format), newPath), Toast.LENGTH_LONG).show();
                }
                command += " --output " + exportFilename;
                commandThread = new CommandThread();
                commandThread.start();
            }
        }
    };
    final Messenger messenger = new Messenger(returnHandler);
    new Runnable() {

        @Override
        public void run() {
            mFileDialog = FileDialogFragment.newInstance(messenger, getString(R.string.title_export_keys), getString(R.string.dialog_specify_export_file_msg), defaultFilename, getString(R.string.label_export_secret_keys), GpgApplication.FILENAME);
            mFileDialog.show(getSupportFragmentManager(), "fileDialog");
        }
    }.run();
}

35. DebugLogActivity#showImportFromFileDialog()

Project: gnupg-for-android
File: DebugLogActivity.java
/**
     * Show dialog to choose a file to import keys from
     */
public void showImportFromFileDialog(final String defaultFilename) {
    // Message is received after file is selected
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            if (message.what == FileDialogFragment.MESSAGE_OK) {
                Bundle data = message.getData();
                String importFilename = new File(data.getString(FileDialogFragment.MESSAGE_DATA_FILENAME)).getAbsolutePath();
                boolean deleteAfterImport = data.getBoolean(FileDialogFragment.MESSAGE_DATA_CHECKED);
                Log.d(TAG, "importFilename: " + importFilename);
                Log.d(TAG, "deleteAfterImport: " + deleteAfterImport);
                command = NativeHelper.gpg2 + " --import " + importFilename;
                commandThread = new CommandThread();
                commandThread.start();
                if (deleteAfterImport)
                    new File(importFilename).delete();
            }
        }
    };
    // Create a new Messenger for the communication back
    final Messenger messenger = new Messenger(returnHandler);
    new Runnable() {

        @Override
        public void run() {
            mFileDialog = FileDialogFragment.newInstance(messenger, getString(R.string.title_import_keys), getString(R.string.dialog_specify_import_file_msg), defaultFilename, null, GpgApplication.FILENAME);
            mFileDialog.show(getSupportFragmentManager(), "fileDialog");
        }
    }.run();
}

36. DebugLogActivity#showDecryptFile()

Project: gnupg-for-android
File: DebugLogActivity.java
/**
     * Show dialog to select file to decrypt
     */
public void showDecryptFile(final String defaultFilename) {
    // Message is received after file is selected
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            if (message.what == FileDialogFragment.MESSAGE_OK) {
                Bundle data = message.getData();
                File f = new File(data.getString(FileDialogFragment.MESSAGE_DATA_FILENAME));
                final String decryptFilename = f.getAbsolutePath();
                final int lastPeriodPos = decryptFilename.lastIndexOf('.');
                String outputFilename = decryptFilename.substring(0, lastPeriodPos);
                command = NativeHelper.gpg2 + "--output " + outputFilename + " --decrypt " + decryptFilename;
                commandThread = new CommandThread();
                commandThread.start();
            }
        }
    };
    // Create a new Messenger for the communication back
    final Messenger messenger = new Messenger(returnHandler);
    new Runnable() {

        @Override
        public void run() {
            mFileDialog = FileDialogFragment.newInstance(messenger, getString(R.string.title_decrypt_file), getString(R.string.dialog_specify_decrypt_file), defaultFilename, null, GpgApplication.FILENAME);
            mFileDialog.show(getSupportFragmentManager(), "fileDialog");
        }
    }.run();
}

37. MainActivity#onClick()

Project: codeexamples-android
File: MainActivity.java
public void onClick(View view) {
    Intent intent = new Intent(this, DownloadService.class);
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(handler);
    // TODO put messages into the intent
    intent.putExtra("MESSENGER", messenger);
    intent.setData(Uri.parse("http://www.vogella.de/index.html"));
    intent.putExtra("urlpath", "http://www.vogella.de/index.html");
    startService(intent);
}

38. MainActivity#onClick()

Project: codeexamples-android
File: MainActivity.java
public void onClick(View view) {
    Intent intent = new Intent(this, DownloadService.class);
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(handler);
    intent.putExtra("MESSENGER", messenger);
    intent.setData(Uri.parse("http://www.vogella.de/index.html"));
    intent.putExtra("urlpath", "http://www.vogella.de/index.html");
    startService(intent);
}

39. FileHelper#saveFile()

Project: apg
File: FileHelper.java
public static void saveFile(final FileDialogCallback callback, final FragmentManager fragmentManager, final String title, final String message, final File defaultFile, final String checkMsg) {
    // Message is received after file is selected
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            if (message.what == FileDialogFragment.MESSAGE_OKAY) {
                callback.onFileSelected(new File(message.getData().getString(FileDialogFragment.MESSAGE_DATA_FILE)), message.getData().getBoolean(FileDialogFragment.MESSAGE_DATA_CHECKED));
            }
        }
    };
    // Create a new Messenger for the communication back
    final Messenger messenger = new Messenger(returnHandler);
    DialogFragmentWorkaround.INTERFACE.runnableRunDelayed(new Runnable() {

        @Override
        public void run() {
            FileDialogFragment fileDialog = FileDialogFragment.newInstance(messenger, title, message, defaultFile, checkMsg);
            fileDialog.show(fragmentManager, "fileDialog");
        }
    });
}

40. ExportHelper#exportKeys()

Project: apg
File: ExportHelper.java
/**
     * Export keys
     */
public void exportKeys(long[] masterKeyIds, boolean exportSecret) {
    Log.d(Constants.TAG, "exportKeys started");
    // Send all information needed to service to export key in other thread
    final Intent intent = new Intent(mActivity, KeychainService.class);
    intent.setAction(KeychainService.ACTION_EXPORT_KEYRING);
    // fill values for this action
    Bundle data = new Bundle();
    data.putString(KeychainService.EXPORT_FILENAME, mExportFile.getAbsolutePath());
    data.putBoolean(KeychainService.EXPORT_SECRET, exportSecret);
    if (masterKeyIds == null) {
        data.putBoolean(KeychainService.EXPORT_ALL, true);
    } else {
        data.putLongArray(KeychainService.EXPORT_KEY_RING_MASTER_KEY_ID, masterKeyIds);
    }
    intent.putExtra(KeychainService.EXTRA_DATA, data);
    // Message is received after exporting is done in KeychainService
    ServiceProgressHandler exportHandler = new ServiceProgressHandler(mActivity) {

        @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 data = message.getData();
                ExportResult result = data.getParcelable(ExportResult.EXTRA_RESULT);
                result.createNotify(mActivity).show();
            }
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(exportHandler);
    intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger);
    // show progress dialog
    exportHandler.showProgressDialog(mActivity.getString(R.string.progress_exporting), ProgressDialog.STYLE_HORIZONTAL, false);
    // start service with intent
    mActivity.startService(intent);
}

41. ViewKeyYubiKeyFragment#promoteToSecretKey()

Project: apg
File: ViewKeyYubiKeyFragment.java
public void promoteToSecretKey() {
    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();
                PromoteKeyResult result = returnData.getParcelable(DecryptVerifyResult.EXTRA_RESULT);
                result.createNotify(getActivity()).show();
            }
        }
    };
    // Send all information needed to service to decrypt in other thread
    Intent intent = new Intent(getActivity(), KeychainService.class);
    // fill values for this action
    intent.setAction(KeychainService.ACTION_PROMOTE_KEYRING);
    Bundle data = new Bundle();
    data.putLong(KeychainService.PROMOTE_MASTER_KEY_ID, mMasterKeyId);
    data.putByteArray(KeychainService.PROMOTE_CARD_AID, mCardAid);
    long[] subKeyIds = new long[mFingerprints.length];
    for (int i = 0; i < subKeyIds.length; i++) {
        subKeyIds[i] = KeyFormattingUtils.getKeyIdFromFingerprint(mFingerprints[i]);
    }
    data.putLongArray(KeychainService.PROMOTE_SUBKEY_IDS, subKeyIds);
    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);
    // start service with intent
    getActivity().startService(intent);
}

42. ViewKeyTrustFragment#verify()

Project: apg
File: ViewKeyTrustFragment.java
private void verify(final Proof proof, final String fingerprint) {
    Intent intent = new Intent(getActivity(), KeychainService.class);
    Bundle data = new Bundle();
    intent.setAction(KeychainService.ACTION_VERIFY_KEYBASE_PROOF);
    data.putString(KeychainService.KEYBASE_PROOF, proof.toString());
    data.putString(KeychainService.KEYBASE_REQUIRED_FINGERPRINT, fingerprint);
    intent.putExtra(KeychainService.EXTRA_DATA, data);
    mProofVerifyDetail.setVisibility(View.GONE);
    // Create a new Messenger for the communication back after proof work is done
    ServiceProgressHandler handler = new ServiceProgressHandler(getActivity()) {

        @Override
        public void handleMessage(Message message) {
            // handle messages by standard KeychainIntentServiceHandler first
            super.handleMessage(message);
            if (message.arg1 == MessageStatus.OKAY.ordinal()) {
                Bundle returnData = message.getData();
                String msg = returnData.getString(ServiceProgressHandler.DATA_MESSAGE);
                SpannableStringBuilder ssb = new SpannableStringBuilder();
                if ((msg != null) && msg.equals("OK")) {
                    //yay
                    String proofUrl = returnData.getString(ServiceProgressHandler.KEYBASE_PROOF_URL);
                    String presenceUrl = returnData.getString(ServiceProgressHandler.KEYBASE_PRESENCE_URL);
                    String presenceLabel = returnData.getString(ServiceProgressHandler.KEYBASE_PRESENCE_LABEL);
                    String proofLabel;
                    switch(proof.getType()) {
                        case Proof.PROOF_TYPE_TWITTER:
                            proofLabel = getString(R.string.keybase_twitter_proof);
                            break;
                        case Proof.PROOF_TYPE_DNS:
                            proofLabel = getString(R.string.keybase_dns_proof);
                            break;
                        case Proof.PROOF_TYPE_WEB_SITE:
                            proofLabel = getString(R.string.keybase_web_site_proof);
                            break;
                        case Proof.PROOF_TYPE_GITHUB:
                            proofLabel = getString(R.string.keybase_github_proof);
                            break;
                        case Proof.PROOF_TYPE_REDDIT:
                            proofLabel = getString(R.string.keybase_reddit_proof);
                            break;
                        default:
                            proofLabel = getString(R.string.keybase_a_post);
                            break;
                    }
                    ssb.append(getString(R.string.keybase_proof_succeeded));
                    StyleSpan bold = new StyleSpan(Typeface.BOLD);
                    ssb.setSpan(bold, 0, ssb.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                    ssb.append("\n\n");
                    int length = ssb.length();
                    ssb.append(proofLabel);
                    if (proofUrl != null) {
                        URLSpan postLink = new URLSpan(proofUrl);
                        ssb.setSpan(postLink, length, length + proofLabel.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                    }
                    if (Proof.PROOF_TYPE_DNS == proof.getType()) {
                        ssb.append(" ").append(getString(R.string.keybase_for_the_domain)).append(" ");
                    } else {
                        ssb.append(" ").append(getString(R.string.keybase_fetched_from)).append(" ");
                    }
                    length = ssb.length();
                    URLSpan presenceLink = new URLSpan(presenceUrl);
                    ssb.append(presenceLabel);
                    ssb.setSpan(presenceLink, length, length + presenceLabel.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                    if (Proof.PROOF_TYPE_REDDIT == proof.getType()) {
                        ssb.append(", ").append(getString(R.string.keybase_reddit_attribution)).append(" “").append(proof.getHandle()).append("”, ");
                    }
                    ssb.append(" ").append(getString(R.string.keybase_contained_signature));
                } else {
                    // verification failed!
                    msg = returnData.getString(ServiceProgressHandler.DATA_ERROR);
                    ssb.append(getString(R.string.keybase_proof_failure));
                    if (msg == null) {
                        msg = getString(R.string.keybase_unknown_proof_failure);
                    }
                    StyleSpan bold = new StyleSpan(Typeface.BOLD);
                    ssb.setSpan(bold, 0, ssb.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                    ssb.append("\n\n").append(msg);
                }
                mProofVerifyHeader.setVisibility(View.VISIBLE);
                mProofVerifyDetail.setVisibility(View.VISIBLE);
                mProofVerifyDetail.setMovementMethod(LinkMovementMethod.getInstance());
                mProofVerifyDetail.setText(ssb);
            }
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(handler);
    intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger);
    // show progress dialog
    handler.showProgressDialog(getString(R.string.progress_verifying_signature), ProgressDialog.STYLE_HORIZONTAL, false);
    // start service with intent
    getActivity().startService(intent);
}

43. ViewKeyActivity#updateFromKeyserver()

Project: apg
File: ViewKeyActivity.java
private void updateFromKeyserver(Uri dataUri, ProviderHelper providerHelper) throws ProviderHelper.NotFoundException {
    mIsRefreshing = true;
    mRefreshItem.setEnabled(false);
    mRefreshItem.setActionView(mRefresh);
    mRefresh.startAnimation(mRotate);
    byte[] blob = (byte[]) providerHelper.getGenericData(KeychainContract.KeyRings.buildUnifiedKeyRingUri(dataUri), KeychainContract.Keys.FINGERPRINT, ProviderHelper.FIELD_TYPE_BLOB);
    String fingerprint = KeyFormattingUtils.convertFingerprintToHex(blob);
    ParcelableKeyRing keyEntry = new ParcelableKeyRing(fingerprint, null, null);
    ArrayList<ParcelableKeyRing> entries = new ArrayList<>();
    entries.add(keyEntry);
    // Message is received after importing is done in KeychainService
    ServiceProgressHandler serviceHandler = new ServiceProgressHandler(this) {

        @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();
                mIsRefreshing = false;
                if (returnData == null) {
                    finish();
                    return;
                }
                final ImportKeyResult result = returnData.getParcelable(OperationResult.EXTRA_RESULT);
                result.createNotify(ViewKeyActivity.this).show();
            }
        }
    };
    // fill values for this action
    Bundle data = new Bundle();
    // search config
    {
        Preferences prefs = Preferences.getPreferences(this);
        Preferences.CloudSearchPrefs cloudPrefs = new Preferences.CloudSearchPrefs(true, true, prefs.getPreferredKeyserver());
        data.putString(KeychainService.IMPORT_KEY_SERVER, cloudPrefs.keyserver);
    }
    data.putParcelableArrayList(KeychainService.IMPORT_KEY_LIST, entries);
    // Send all information needed to service to query keys in other thread
    Intent intent = new Intent(this, KeychainService.class);
    intent.setAction(KeychainService.ACTION_IMPORT_KEYRING);
    intent.putExtra(KeychainService.EXTRA_DATA, data);
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(serviceHandler);
    intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger);
    // start service with intent
    startService(intent);
}

44. UploadKeyActivity#uploadKey()

Project: apg
File: UploadKeyActivity.java
private void uploadKey() {
    // Send all information needed to service to upload key in other thread
    Intent intent = new Intent(this, KeychainService.class);
    intent.setAction(KeychainService.ACTION_UPLOAD_KEYRING);
    // set data uri as path to keyring
    Uri blobUri = KeyRings.buildUnifiedKeyRingUri(mDataUri);
    intent.setData(blobUri);
    // fill values for this action
    Bundle data = new Bundle();
    String server = (String) mKeyServerSpinner.getSelectedItem();
    data.putString(KeychainService.UPLOAD_KEY_SERVER, server);
    intent.putExtra(KeychainService.EXTRA_DATA, data);
    // Message is received after uploading 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()) {
                Toast.makeText(UploadKeyActivity.this, R.string.msg_crt_upload_success, Toast.LENGTH_SHORT).show();
                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(getString(R.string.progress_uploading), ProgressDialog.STYLE_HORIZONTAL, false);
    // start service with intent
    startService(intent);
}

45. SettingsKeyServerActivity#onClick()

Project: apg
File: SettingsKeyServerActivity.java
// button to add keyserver clicked
public void onClick(View v) {
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            Bundle data = message.getData();
            switch(message.what) {
                case AddKeyserverDialogFragment.MESSAGE_OKAY:
                    {
                        boolean verified = data.getBoolean(AddKeyserverDialogFragment.MESSAGE_VERIFIED);
                        if (verified) {
                            Notify.create(SettingsKeyServerActivity.this, R.string.add_keyserver_verified, Notify.Style.OK).show();
                        } else {
                            Notify.create(SettingsKeyServerActivity.this, R.string.add_keyserver_without_verification, Notify.Style.WARN).show();
                        }
                        String keyserver = data.getString(AddKeyserverDialogFragment.MESSAGE_KEYSERVER);
                        addKeyserver(keyserver);
                        break;
                    }
                case AddKeyserverDialogFragment.MESSAGE_VERIFICATION_FAILED:
                    {
                        AddKeyserverDialogFragment.FailureReason failureReason = (AddKeyserverDialogFragment.FailureReason) data.getSerializable(AddKeyserverDialogFragment.MESSAGE_FAILURE_REASON);
                        switch(failureReason) {
                            case CONNECTION_FAILED:
                                {
                                    Notify.create(SettingsKeyServerActivity.this, R.string.add_keyserver_connection_failed, Notify.Style.ERROR).show();
                                    break;
                                }
                            case INVALID_URL:
                                {
                                    Notify.create(SettingsKeyServerActivity.this, R.string.add_keyserver_invalid_url, Notify.Style.ERROR).show();
                                    break;
                                }
                        }
                        break;
                    }
            }
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(returnHandler);
    AddKeyserverDialogFragment dialogFragment = AddKeyserverDialogFragment.newInstance(messenger);
    dialogFragment.show(getSupportFragmentManager(), "addKeyserverDialog");
}

46. KeyListFragment#consolidate()

Project: apg
File: KeyListFragment.java
private void consolidate() {
    // Message is received after importing is done in KeychainService
    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 ConsolidateResult result = returnData.getParcelable(OperationResult.EXTRA_RESULT);
                if (result == null) {
                    return;
                }
                result.createNotify(getActivity()).show();
            }
        }
    };
    // Send all information needed to service to import key in other thread
    Intent intent = new Intent(getActivity(), KeychainService.class);
    intent.setAction(KeychainService.ACTION_CONSOLIDATE);
    // 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);
}

47. KeyListFragment#updateAllKeys()

Project: apg
File: KeyListFragment.java
private void updateAllKeys() {
    Activity activity = getActivity();
    if (activity == null) {
        return;
    }
    ProviderHelper providerHelper = new ProviderHelper(activity);
    Cursor cursor = providerHelper.getContentResolver().query(KeyRings.buildUnifiedKeyRingsUri(), new String[] { KeyRings.FINGERPRINT }, null, null, null);
    if (cursor == null) {
        Notify.create(activity, R.string.error_loading_keys, Style.ERROR);
        return;
    }
    ArrayList<ParcelableKeyRing> keyList = new ArrayList<>();
    try {
        while (cursor.moveToNext()) {
            //fingerprint column is 0
            byte[] blob = cursor.getBlob(0);
            String fingerprint = KeyFormattingUtils.convertFingerprintToHex(blob);
            ParcelableKeyRing keyEntry = new ParcelableKeyRing(fingerprint, null, null);
            keyList.add(keyEntry);
        }
    } finally {
        cursor.close();
    }
    ServiceProgressHandler serviceHandler = 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 ImportKeyResult result = returnData.getParcelable(OperationResult.EXTRA_RESULT);
                if (result == null) {
                    Log.e(Constants.TAG, "result == null");
                    return;
                }
                result.createNotify(getActivity()).show();
            }
        }
    };
    // Send all information needed to service to query keys in other thread
    Intent intent = new Intent(getActivity(), KeychainService.class);
    intent.setAction(KeychainService.ACTION_IMPORT_KEYRING);
    // fill values for this action
    Bundle data = new Bundle();
    // search config
    {
        Preferences prefs = Preferences.getPreferences(getActivity());
        Preferences.CloudSearchPrefs cloudPrefs = new Preferences.CloudSearchPrefs(true, true, prefs.getPreferredKeyserver());
        data.putString(KeychainService.IMPORT_KEY_SERVER, cloudPrefs.keyserver);
    }
    data.putParcelableArrayList(KeychainService.IMPORT_KEY_LIST, keyList);
    intent.putExtra(KeychainService.EXTRA_DATA, data);
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(serviceHandler);
    intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger);
    // show progress dialog
    serviceHandler.showProgressDialog(getString(R.string.progress_updating), ProgressDialog.STYLE_HORIZONTAL, true);
    // start service with intent
    getActivity().startService(intent);
}

48. KeyListFragment#showDeleteKeyDialog()

Project: apg
File: KeyListFragment.java
/**
     * Show dialog to delete key
     *
     * @param hasSecret must contain whether the list of masterKeyIds contains a secret key or not
     */
public void showDeleteKeyDialog(final ActionMode mode, long[] masterKeyIds, boolean hasSecret) {
    // Can only work on singular secret keys
    if (hasSecret && masterKeyIds.length > 1) {
        Notify.create(getActivity(), R.string.secret_cannot_multiple, Notify.Style.ERROR).show();
        return;
    }
    // Message is received after key is deleted
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            if (message.arg1 == DeleteKeyDialogFragment.MESSAGE_OKAY) {
                Bundle data = message.getData();
                if (data != null) {
                    DeleteResult result = data.getParcelable(DeleteResult.EXTRA_RESULT);
                    if (result != null) {
                        result.createNotify(getActivity()).show();
                    }
                }
                mode.finish();
            }
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(returnHandler);
    DeleteKeyDialogFragment deleteKeyDialog = DeleteKeyDialogFragment.newInstance(messenger, masterKeyIds);
    deleteKeyDialog.show(getActivity().getSupportFragmentManager(), "deleteKeyDialog");
}

49. ImportKeysProxyActivity#startImportService()

Project: apg
File: ImportKeysProxyActivity.java
private void startImportService(ArrayList<ParcelableKeyRing> keyRings) {
    // Message is received after importing is done in KeychainService
    ServiceProgressHandler serviceHandler = new ServiceProgressHandler(this) {

        @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) {
                    finish();
                    return;
                }
                final ImportKeyResult result = returnData.getParcelable(OperationResult.EXTRA_RESULT);
                if (result == null) {
                    Log.e(Constants.TAG, "result == null");
                    finish();
                    return;
                }
                if (!result.success()) {
                    // only return if no success...
                    Intent data = new Intent();
                    data.putExtras(returnData);
                    returnResult(data);
                    return;
                }
                Intent certifyIntent = new Intent(ImportKeysProxyActivity.this, CertifyKeyActivity.class);
                certifyIntent.putExtra(CertifyKeyActivity.EXTRA_RESULT, result);
                certifyIntent.putExtra(CertifyKeyActivity.EXTRA_KEY_IDS, result.getImportedMasterKeyIds());
                startActivityForResult(certifyIntent, 0);
            }
        }
    };
    // fill values for this action
    Bundle data = new Bundle();
    // search config
    {
        Preferences prefs = Preferences.getPreferences(this);
        Preferences.CloudSearchPrefs cloudPrefs = new Preferences.CloudSearchPrefs(true, true, prefs.getPreferredKeyserver());
        data.putString(KeychainService.IMPORT_KEY_SERVER, cloudPrefs.keyserver);
    }
    data.putParcelableArrayList(KeychainService.IMPORT_KEY_LIST, keyRings);
    // Send all information needed to service to query keys in other thread
    Intent intent = new Intent(this, KeychainService.class);
    intent.setAction(KeychainService.ACTION_IMPORT_KEYRING);
    intent.putExtra(KeychainService.EXTRA_DATA, data);
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(serviceHandler);
    intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger);
    // show progress dialog
    serviceHandler.showProgressDialog(getString(R.string.progress_importing), ProgressDialog.STYLE_HORIZONTAL, true);
    // start service with intent
    startService(intent);
}

50. EditKeyFragment#editSubkeyExpiry()

Project: apg
File: EditKeyFragment.java
private void editSubkeyExpiry(final int position) {
    final long keyId = mSubkeysAdapter.getKeyId(position);
    final Long creationDate = mSubkeysAdapter.getCreationDate(position);
    final Long expiryDate = mSubkeysAdapter.getExpiryDate(position);
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            switch(message.what) {
                case EditSubkeyExpiryDialogFragment.MESSAGE_NEW_EXPIRY:
                    mSaveKeyringParcel.getOrCreateSubkeyChange(keyId).mExpiry = (Long) message.getData().getSerializable(EditSubkeyExpiryDialogFragment.MESSAGE_DATA_EXPIRY);
                    break;
            }
            getLoaderManager().getLoader(LOADER_ID_SUBKEYS).forceLoad();
        }
    };
    // Create a new Messenger for the communication back
    final Messenger messenger = new Messenger(returnHandler);
    DialogFragmentWorkaround.INTERFACE.runnableRunDelayed(new Runnable() {

        public void run() {
            EditSubkeyExpiryDialogFragment dialogFragment = EditSubkeyExpiryDialogFragment.newInstance(messenger, creationDate, expiryDate);
            dialogFragment.show(getActivity().getSupportFragmentManager(), "editSubkeyExpiryDialog");
        }
    });
}

51. EditKeyFragment#editSubkey()

Project: apg
File: EditKeyFragment.java
private void editSubkey(final int position) {
    final long keyId = mSubkeysAdapter.getKeyId(position);
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            switch(message.what) {
                case EditSubkeyDialogFragment.MESSAGE_CHANGE_EXPIRY:
                    editSubkeyExpiry(position);
                    break;
                case EditSubkeyDialogFragment.MESSAGE_REVOKE:
                    // toggle
                    if (mSaveKeyringParcel.mRevokeSubKeys.contains(keyId)) {
                        mSaveKeyringParcel.mRevokeSubKeys.remove(keyId);
                    } else {
                        mSaveKeyringParcel.mRevokeSubKeys.add(keyId);
                    }
                    break;
                case EditSubkeyDialogFragment.MESSAGE_STRIP:
                    {
                        SecretKeyType secretKeyType = mSubkeysAdapter.getSecretKeyType(position);
                        if (secretKeyType == SecretKeyType.GNU_DUMMY) {
                            // Key is already stripped; this is a no-op.
                            break;
                        }
                        SubkeyChange change = mSaveKeyringParcel.getSubkeyChange(keyId);
                        if (change == null) {
                            mSaveKeyringParcel.mChangeSubKeys.add(new SubkeyChange(keyId, true, false));
                            break;
                        }
                        // toggle
                        change.mDummyStrip = !change.mDummyStrip;
                        if (change.mDummyStrip && change.mMoveKeyToCard) {
                            // User had chosen to divert key, but now wants to strip it instead.
                            change.mMoveKeyToCard = false;
                        }
                        break;
                    }
                case EditSubkeyDialogFragment.MESSAGE_KEYTOCARD:
                    {
                        Activity activity = EditKeyFragment.this.getActivity();
                        SecretKeyType secretKeyType = mSubkeysAdapter.getSecretKeyType(position);
                        if (secretKeyType == SecretKeyType.DIVERT_TO_CARD || secretKeyType == SecretKeyType.GNU_DUMMY) {
                            Notify.create(activity, R.string.edit_key_error_bad_nfc_stripped, Notify.Style.ERROR).show((ViewGroup) activity.findViewById(R.id.import_snackbar));
                            break;
                        }
                        int algorithm = mSubkeysAdapter.getAlgorithm(position);
                        // these are the PGP constants for RSA_GENERAL, RSA_ENCRYPT and RSA_SIGN
                        if (algorithm != 1 && algorithm != 2 && algorithm != 3) {
                            Notify.create(activity, R.string.edit_key_error_bad_nfc_algo, Notify.Style.ERROR).show((ViewGroup) activity.findViewById(R.id.import_snackbar));
                            break;
                        }
                        if (mSubkeysAdapter.getKeySize(position) != 2048) {
                            Notify.create(activity, R.string.edit_key_error_bad_nfc_size, Notify.Style.ERROR).show((ViewGroup) activity.findViewById(R.id.import_snackbar));
                            break;
                        }
                        SubkeyChange change;
                        change = mSaveKeyringParcel.getSubkeyChange(keyId);
                        if (change == null) {
                            mSaveKeyringParcel.mChangeSubKeys.add(new SubkeyChange(keyId, false, true));
                            break;
                        }
                        // toggle
                        change.mMoveKeyToCard = !change.mMoveKeyToCard;
                        if (change.mMoveKeyToCard && change.mDummyStrip) {
                            // User had chosen to strip key, but now wants to divert it.
                            change.mDummyStrip = false;
                        }
                        break;
                    }
            }
            getLoaderManager().getLoader(LOADER_ID_SUBKEYS).forceLoad();
        }
    };
    // Create a new Messenger for the communication back
    final Messenger messenger = new Messenger(returnHandler);
    DialogFragmentWorkaround.INTERFACE.runnableRunDelayed(new Runnable() {

        public void run() {
            EditSubkeyDialogFragment dialogFragment = EditSubkeyDialogFragment.newInstance(messenger);
            dialogFragment.show(getActivity().getSupportFragmentManager(), "editSubkeyDialog");
        }
    });
}

52. EditKeyFragment#editUserId()

Project: apg
File: EditKeyFragment.java
private void editUserId(final int position) {
    final String userId = mUserIdsAdapter.getUserId(position);
    final boolean isRevoked = mUserIdsAdapter.getIsRevoked(position);
    final boolean isRevokedPending = mUserIdsAdapter.getIsRevokedPending(position);
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            switch(message.what) {
                case EditUserIdDialogFragment.MESSAGE_CHANGE_PRIMARY_USER_ID:
                    // toggle
                    if (mSaveKeyringParcel.mChangePrimaryUserId != null && mSaveKeyringParcel.mChangePrimaryUserId.equals(userId)) {
                        mSaveKeyringParcel.mChangePrimaryUserId = null;
                    } else {
                        mSaveKeyringParcel.mChangePrimaryUserId = userId;
                    }
                    break;
                case EditUserIdDialogFragment.MESSAGE_REVOKE:
                    // toggle
                    if (mSaveKeyringParcel.mRevokeUserIds.contains(userId)) {
                        mSaveKeyringParcel.mRevokeUserIds.remove(userId);
                    } else {
                        mSaveKeyringParcel.mRevokeUserIds.add(userId);
                        // not possible to revoke and change to primary user id
                        if (mSaveKeyringParcel.mChangePrimaryUserId != null && mSaveKeyringParcel.mChangePrimaryUserId.equals(userId)) {
                            mSaveKeyringParcel.mChangePrimaryUserId = null;
                        }
                    }
                    break;
            }
            getLoaderManager().getLoader(LOADER_ID_USER_IDS).forceLoad();
        }
    };
    // Create a new Messenger for the communication back
    final Messenger messenger = new Messenger(returnHandler);
    DialogFragmentWorkaround.INTERFACE.runnableRunDelayed(new Runnable() {

        public void run() {
            EditUserIdDialogFragment dialogFragment = EditUserIdDialogFragment.newInstance(messenger, isRevoked, isRevokedPending);
            dialogFragment.show(getActivity().getSupportFragmentManager(), "editUserIdDialog");
        }
    });
}

53. EditKeyFragment#changePassphrase()

Project: apg
File: EditKeyFragment.java
private void changePassphrase() {
    //        Intent passIntent = new Intent(getActivity(), PassphraseWizardActivity.class);
    //        passIntent.setAction(PassphraseWizardActivity.CREATE_METHOD);
    //        startActivityForResult(passIntent, 12);
    // Message is received after passphrase is cached
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            if (message.what == SetPassphraseDialogFragment.MESSAGE_OKAY) {
                Bundle data = message.getData();
                // cache new returned passphrase!
                mSaveKeyringParcel.mNewUnlock = new ChangeUnlockParcel((Passphrase) data.getParcelable(SetPassphraseDialogFragment.MESSAGE_NEW_PASSPHRASE), null);
            }
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(returnHandler);
    SetPassphraseDialogFragment setPassphraseDialog = SetPassphraseDialogFragment.newInstance(messenger, R.string.title_change_passphrase);
    setPassphraseDialog.show(getActivity().getSupportFragmentManager(), "setPassphraseDialog");
}

54. DeleteKeyDialogFragment#onCreateDialog()

Project: apg
File: DeleteKeyDialogFragment.java
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    final FragmentActivity activity = getActivity();
    final Messenger messenger = getArguments().getParcelable(ARG_MESSENGER);
    final long[] masterKeyIds = getArguments().getLongArray(ARG_DELETE_MASTER_KEY_IDS);
    CustomAlertDialogBuilder builder = new CustomAlertDialogBuilder(activity);
    // Setup custom View to display in AlertDialog
    LayoutInflater inflater = activity.getLayoutInflater();
    mInflateView = inflater.inflate(R.layout.view_key_delete_fragment, null);
    builder.setView(mInflateView);
    mMainMessage = (TextView) mInflateView.findViewById(R.id.mainMessage);
    final boolean hasSecret;
    // If only a single key has been selected
    if (masterKeyIds.length == 1) {
        long masterKeyId = masterKeyIds[0];
        try {
            HashMap<String, Object> data = new ProviderHelper(activity).getUnifiedData(masterKeyId, new String[] { KeyRings.USER_ID, KeyRings.HAS_ANY_SECRET }, new int[] { ProviderHelper.FIELD_TYPE_STRING, ProviderHelper.FIELD_TYPE_INTEGER });
            String name;
            KeyRing.UserId mainUserId = KeyRing.splitUserId((String) data.get(KeyRings.USER_ID));
            if (mainUserId.name != null) {
                name = mainUserId.name;
            } else {
                name = getString(R.string.user_id_no_name);
            }
            hasSecret = ((Long) data.get(KeyRings.HAS_ANY_SECRET)) == 1;
            if (hasSecret) {
                // show title only for secret key deletions,
                // see http://www.google.com/design/spec/components/dialogs.html#dialogs-behavior
                builder.setTitle(getString(R.string.title_delete_secret_key, name));
                mMainMessage.setText(getString(R.string.secret_key_deletion_confirmation, name));
            } else {
                mMainMessage.setText(getString(R.string.public_key_deletetion_confirmation, name));
            }
        } catch (ProviderHelper.NotFoundException e) {
            dismiss();
            return null;
        }
    } else {
        mMainMessage.setText(R.string.key_deletion_confirmation_multi);
        hasSecret = false;
    }
    builder.setPositiveButton(R.string.btn_delete, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            // Send all information needed to service to import key in other thread
            Intent intent = new Intent(getActivity(), KeychainService.class);
            intent.setAction(KeychainService.ACTION_DELETE);
            // Message is received after importing is done in KeychainService
            ServiceProgressHandler saveHandler = new ServiceProgressHandler(getActivity()) {

                @Override
                public void handleMessage(Message message) {
                    super.handleMessage(message);
                    // handle messages by standard KeychainIntentServiceHandler first
                    if (message.arg1 == MessageStatus.OKAY.ordinal()) {
                        try {
                            Message msg = Message.obtain();
                            msg.copyFrom(message);
                            messenger.send(msg);
                        } catch (RemoteException e) {
                            Log.e(Constants.TAG, "messenger error", e);
                        }
                    }
                }
            };
            // fill values for this action
            Bundle data = new Bundle();
            data.putLongArray(KeychainService.DELETE_KEY_LIST, masterKeyIds);
            data.putBoolean(KeychainService.DELETE_IS_SECRET, hasSecret);
            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_deleting), ProgressDialog.STYLE_HORIZONTAL, true);
            // start service with intent
            getActivity().startService(intent);
            dismiss();
        }
    });
    builder.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int id) {
            dismiss();
        }
    });
    return builder.show();
}

55. DecryptFragment#lookupUnknownKey()

Project: apg
File: DecryptFragment.java
private void lookupUnknownKey(long unknownKeyId) {
    // Message is received after importing is done in KeychainService
    ServiceProgressHandler serviceHandler = 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 ImportKeyResult result = returnData.getParcelable(OperationResult.EXTRA_RESULT);
                result.createNotify(getActivity()).show();
                getLoaderManager().restartLoader(LOADER_ID_UNIFIED, null, DecryptFragment.this);
            }
        }
    };
    // fill values for this action
    Bundle data = new Bundle();
    // search config
    {
        Preferences prefs = Preferences.getPreferences(getActivity());
        Preferences.CloudSearchPrefs cloudPrefs = new Preferences.CloudSearchPrefs(true, true, prefs.getPreferredKeyserver());
        data.putString(KeychainService.IMPORT_KEY_SERVER, cloudPrefs.keyserver);
    }
    {
        ParcelableKeyRing keyEntry = new ParcelableKeyRing(null, KeyFormattingUtils.convertKeyIdToHex(unknownKeyId), null);
        ArrayList<ParcelableKeyRing> selectedEntries = new ArrayList<>();
        selectedEntries.add(keyEntry);
        data.putParcelableArrayList(KeychainService.IMPORT_KEY_LIST, selectedEntries);
    }
    // Send all information needed to service to query keys in other thread
    Intent intent = new Intent(getActivity(), KeychainService.class);
    intent.setAction(KeychainService.ACTION_IMPORT_KEYRING);
    intent.putExtra(KeychainService.EXTRA_DATA, data);
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(serviceHandler);
    intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger);
    getActivity().startService(intent);
}

56. CreateKeyYubiKeyImportFragment#importKey()

Project: apg
File: CreateKeyYubiKeyImportFragment.java
public void importKey() {
    // Message is received after decrypting is done in KeychainService
    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();
                ImportKeyResult result = returnData.getParcelable(DecryptVerifyResult.EXTRA_RESULT);
                long[] masterKeyIds = result.getImportedMasterKeyIds();
                if (!result.success() || masterKeyIds.length == 0) {
                    result.createNotify(getActivity()).show();
                    return;
                }
                Intent intent = new Intent(getActivity(), ViewKeyActivity.class);
                // use the imported masterKeyId, not the one from the yubikey, because
                // that one might* just have been a subkey of the imported key
                intent.setData(KeyRings.buildGenericKeyRingUri(masterKeyIds[0]));
                intent.putExtra(ViewKeyActivity.EXTRA_DISPLAY_RESULT, result);
                intent.putExtra(ViewKeyActivity.EXTRA_NFC_AID, mNfcAid);
                intent.putExtra(ViewKeyActivity.EXTRA_NFC_USER_ID, mNfcUserId);
                intent.putExtra(ViewKeyActivity.EXTRA_NFC_FINGERPRINTS, mNfcFingerprints);
                startActivity(intent);
                getActivity().finish();
            }
        }
    };
    // 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_IMPORT_KEYRING);
    ArrayList<ParcelableKeyRing> keyList = new ArrayList<>();
    keyList.add(new ParcelableKeyRing(mNfcFingerprint, null, null));
    data.putParcelableArrayList(KeychainService.IMPORT_KEY_LIST, keyList);
    {
        Preferences prefs = Preferences.getPreferences(getActivity());
        Preferences.CloudSearchPrefs cloudPrefs = new Preferences.CloudSearchPrefs(true, true, prefs.getPreferredKeyserver());
        data.putString(KeychainService.IMPORT_KEY_SERVER, cloudPrefs.keyserver);
    }
    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);
    saveHandler.showProgressDialog(getString(R.string.progress_importing), ProgressDialog.STYLE_HORIZONTAL, false);
    // start service with intent
    getActivity().startService(intent);
}

57. CreateKeyFinalFragment#uploadKey()

Project: apg
File: CreateKeyFinalFragment.java
// TODO move into EditKeyOperation
private void uploadKey(final EditKeyResult saveKeyResult) {
    // Send all information needed to service to upload key in other thread
    final Intent intent = new Intent(getActivity(), KeychainService.class);
    intent.setAction(KeychainService.ACTION_UPLOAD_KEYRING);
    // set data uri as path to keyring
    Uri blobUri = KeychainContract.KeyRings.buildUnifiedKeyRingUri(saveKeyResult.mMasterKeyId);
    intent.setData(blobUri);
    // fill values for this action
    Bundle data = new Bundle();
    // upload to favorite keyserver
    String keyserver = Preferences.getPreferences(getActivity()).getPreferredKeyserver();
    data.putString(KeychainService.UPLOAD_KEY_SERVER, keyserver);
    intent.putExtra(KeychainService.EXTRA_DATA, data);
    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()) {
                // TODO: upload operation needs a result!
                // TODO: then combine these results
                //if (result.getResult() == OperationResultParcel.RESULT_OK) {
                //Notify.create(getActivity(), R.string.key_send_success,
                //Notify.Style.OK).show();
                Intent data = new Intent();
                data.putExtra(OperationResult.EXTRA_RESULT, saveKeyResult);
                getActivity().setResult(Activity.RESULT_OK, data);
                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(getString(R.string.progress_uploading), ProgressDialog.STYLE_HORIZONTAL, false);
    // start service with intent
    getActivity().startService(intent);
}

58. CreateKeyFinalFragment#createKey()

Project: apg
File: CreateKeyFinalFragment.java
private void createKey() {
    Intent intent = new Intent(getActivity(), KeychainService.class);
    intent.setAction(KeychainService.ACTION_EDIT_KEYRING);
    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 EditKeyResult result = returnData.getParcelable(OperationResult.EXTRA_RESULT);
                if (result == null) {
                    Log.e(Constants.TAG, "result == null");
                    return;
                }
                if (result.mMasterKeyId != null && mUploadCheckbox.isChecked()) {
                    // result will be displayed after upload
                    uploadKey(result);
                } else {
                    Intent data = new Intent();
                    data.putExtra(OperationResult.EXTRA_RESULT, result);
                    getActivity().setResult(Activity.RESULT_OK, data);
                    getActivity().finish();
                }
            }
        }
    };
    // fill values for this action
    Bundle data = new Bundle();
    // get selected key entries
    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);
    saveHandler.showProgressDialog(getString(R.string.progress_building_key), ProgressDialog.STYLE_HORIZONTAL, false);
    getActivity().startService(intent);
}

59. ConsolidateDialogActivity#consolidateRecovery()

Project: apg
File: ConsolidateDialogActivity.java
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()) {
                /* don't care about the results (for now?)

                    // get returned data bundle
                    Bundle returnData = message.getInputData();
                    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);
}

60. CryptoOperationFragment#cryptoOperation()

Project: apg
File: CryptoOperationFragment.java
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);
}

61. PassphraseCacheService#getCachedPassphrase()

Project: apg
File: PassphraseCacheService.java
/**
     * Gets a cached passphrase from memory by sending an intent to the service. This method is
     * designed to wait until the service returns the passphrase.
     *
     * @return passphrase or null (if no passphrase is cached for this keyId)
     */
public static Passphrase getCachedPassphrase(Context context, long masterKeyId, long subKeyId) throws KeyNotFoundException {
    Log.d(Constants.TAG, "PassphraseCacheService.getCachedPassphrase() for masterKeyId " + masterKeyId + ", subKeyId " + subKeyId);
    Intent intent = new Intent(context, PassphraseCacheService.class);
    intent.setAction(ACTION_PASSPHRASE_CACHE_GET);
    final Object mutex = new Object();
    final Message returnMessage = Message.obtain();
    HandlerThread handlerThread = new HandlerThread("getPassphraseThread");
    handlerThread.start();
    Handler returnHandler = new Handler(handlerThread.getLooper()) {

        @Override
        public void handleMessage(Message message) {
            // copy over result to handle after mutex.wait
            returnMessage.what = message.what;
            returnMessage.copyFrom(message);
            synchronized (mutex) {
                mutex.notify();
            }
            // quit handlerThread
            getLooper().quit();
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(returnHandler);
    intent.putExtra(EXTRA_KEY_ID, masterKeyId);
    intent.putExtra(EXTRA_SUBKEY_ID, subKeyId);
    intent.putExtra(EXTRA_MESSENGER, messenger);
    // send intent to this service
    context.startService(intent);
    // noinspection SynchronizationOnLocalVariableOrMethodParameter
    synchronized (mutex) {
        try {
            mutex.wait(3000);
        } catch (InterruptedException e) {
        }
    }
    switch(returnMessage.what) {
        case MSG_PASSPHRASE_CACHE_GET_OKAY:
            Bundle returnData = returnMessage.getData();
            returnData.setClassLoader(context.getClassLoader());
            return returnData.getParcelable(EXTRA_PASSPHRASE);
        case MSG_PASSPHRASE_CACHE_GET_KEY_NOT_FOUND:
            throw new KeyNotFoundException();
        default:
            Log.e(Constants.TAG, "timeout case!");
            throw new KeyNotFoundException("should not happen!");
    }
}

62. CryptoInputParcelCacheService#getCryptoInputParcel()

Project: apg
File: CryptoInputParcelCacheService.java
private static CryptoInputParcel getCryptoInputParcel(Context context, UUID uuid) throws InputParcelNotFound {
    Intent intent = new Intent(context, CryptoInputParcelCacheService.class);
    intent.setAction(ACTION_GET);
    final Object mutex = new Object();
    final Message returnMessage = Message.obtain();
    HandlerThread handlerThread = new HandlerThread("getParcelableThread");
    handlerThread.start();
    Handler returnHandler = new Handler(handlerThread.getLooper()) {

        @Override
        public void handleMessage(Message message) {
            // copy over result to handle after mutex.wait
            returnMessage.what = message.what;
            returnMessage.copyFrom(message);
            synchronized (mutex) {
                mutex.notify();
            }
            // quit handlerThread
            getLooper().quit();
        }
    };
    // Create a new Messenger for the communication back
    Messenger messenger = new Messenger(returnHandler);
    intent.putExtra(EXTRA_UUID1, uuid.getMostSignificantBits());
    intent.putExtra(EXTRA_UUID2, uuid.getLeastSignificantBits());
    intent.putExtra(EXTRA_MESSENGER, messenger);
    // send intent to this service
    context.startService(intent);
    // noinspection SynchronizationOnLocalVariableOrMethodParameter
    synchronized (mutex) {
        try {
            mutex.wait(3000);
        } catch (InterruptedException e) {
        }
    }
    switch(returnMessage.what) {
        case MSG_GET_OKAY:
            Bundle returnData = returnMessage.getData();
            returnData.setClassLoader(context.getClassLoader());
            return returnData.getParcelable(EXTRA_CRYPTO_INPUT_PARCEL);
        case MSG_GET_NOT_FOUND:
            throw new InputParcelNotFound();
        default:
            Log.e(Constants.TAG, "timeout!");
            throw new InputParcelNotFound("should not happen!");
    }
}

63. MemoryServiceConnection#onServiceConnected()

Project: Android-Developer-Toolbelt
File: MemoryServiceConnection.java
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
    mMessenger = new Messenger(service);
    mConnected = true;
}

64. TracksAdapter#fetchDataFromService()

Project: serenity-android
File: TracksAdapter.java
protected void fetchDataFromService() {
    posterGalleryHandler = new MusicHandler();
    Messenger messenger = new Messenger(posterGalleryHandler);
    Intent intent = new Intent(context, MusicTrackRetrievalIntentService.class);
    intent.putExtra("MESSENGER", messenger);
    intent.putExtra("key", key);
    context.startService(intent);
}

65. MusicPosterGridViewAdapter#fetchDataFromService()

Project: serenity-android
File: MusicPosterGridViewAdapter.java
protected void fetchDataFromService() {
    posterGalleryHandler = new MusicHandler();
    Messenger messenger = new Messenger(posterGalleryHandler);
    Intent intent = new Intent(context, MusicRetrievalIntentService.class);
    intent.putExtra("MESSENGER", messenger);
    intent.putExtra("key", key);
    intent.putExtra("category", category);
    context.startService(intent);
}

66. MusicPosterGalleryAdapter#fetchData()

Project: serenity-android
File: MusicPosterGalleryAdapter.java
protected void fetchData() {
    handler = new ArtistRetrievalHandler();
    Messenger messenger = new Messenger(handler);
    Intent intent = new Intent(context, MusicRetrievalIntentService.class);
    intent.putExtra("MESSENGER", messenger);
    intent.putExtra("key", key);
    intent.putExtra("category", category);
    context.startService(intent);
}

67. MusicAlbumsCoverAdapter#fetchDataFromService()

Project: serenity-android
File: MusicAlbumsCoverAdapter.java
protected void fetchDataFromService() {
    posterGalleryHandler = new MusicHandler();
    Messenger messenger = new Messenger(posterGalleryHandler);
    Intent intent = new Intent(context, MusicAlbumRetrievalIntentService.class);
    intent.putExtra("MESSENGER", messenger);
    intent.putExtra("key", key);
    context.startService(intent);
}

68. ViewKeyAdvUserIdsFragment#editUserId()

Project: open-keychain
File: ViewKeyAdvUserIdsFragment.java
private void editUserId(final int position) {
    final String userId = mUserIdsAdapter.getUserId(position);
    final boolean isRevoked = mUserIdsAdapter.getIsRevoked(position);
    final boolean isRevokedPending = mUserIdsAdapter.getIsRevokedPending(position);
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            switch(message.what) {
                case EditUserIdDialogFragment.MESSAGE_CHANGE_PRIMARY_USER_ID:
                    // toggle
                    if (mEditModeSaveKeyringParcel.mChangePrimaryUserId != null && mEditModeSaveKeyringParcel.mChangePrimaryUserId.equals(userId)) {
                        mEditModeSaveKeyringParcel.mChangePrimaryUserId = null;
                    } else {
                        mEditModeSaveKeyringParcel.mChangePrimaryUserId = userId;
                    }
                    break;
                case EditUserIdDialogFragment.MESSAGE_REVOKE:
                    // toggle
                    if (mEditModeSaveKeyringParcel.mRevokeUserIds.contains(userId)) {
                        mEditModeSaveKeyringParcel.mRevokeUserIds.remove(userId);
                    } else {
                        mEditModeSaveKeyringParcel.mRevokeUserIds.add(userId);
                        // not possible to revoke and change to primary user id
                        if (mEditModeSaveKeyringParcel.mChangePrimaryUserId != null && mEditModeSaveKeyringParcel.mChangePrimaryUserId.equals(userId)) {
                            mEditModeSaveKeyringParcel.mChangePrimaryUserId = null;
                        }
                    }
                    break;
            }
            getLoaderManager().getLoader(LOADER_ID_USER_IDS).forceLoad();
        }
    };
    // Create a new Messenger for the communication back
    final Messenger messenger = new Messenger(returnHandler);
    DialogFragmentWorkaround.INTERFACE.runnableRunDelayed(new Runnable() {

        public void run() {
            EditUserIdDialogFragment dialogFragment = EditUserIdDialogFragment.newInstance(messenger, isRevoked, isRevokedPending);
            dialogFragment.show(getActivity().getSupportFragmentManager(), "editUserIdDialog");
        }
    });
}

69. ViewKeyAdvSubkeysFragment#editSubkeyExpiry()

Project: open-keychain
File: ViewKeyAdvSubkeysFragment.java
private void editSubkeyExpiry(final int position) {
    final long keyId = mSubkeysAdapter.getKeyId(position);
    final Long creationDate = mSubkeysAdapter.getCreationDate(position);
    final Long expiryDate = mSubkeysAdapter.getExpiryDate(position);
    Handler returnHandler = new Handler() {

        @Override
        public void handleMessage(Message message) {
            switch(message.what) {
                case EditSubkeyExpiryDialogFragment.MESSAGE_NEW_EXPIRY:
                    mEditModeSaveKeyringParcel.getOrCreateSubkeyChange(keyId).mExpiry = (Long) message.getData().getSerializable(EditSubkeyExpiryDialogFragment.MESSAGE_DATA_EXPIRY);
                    break;
            }
            getLoaderManager().getLoader(LOADER_ID_SUBKEYS).forceLoad();
        }
    };
    // Create a new Messenger for the communication back
    final Messenger messenger = new Messenger(returnHandler);
    DialogFragmentWorkaround.INTERFACE.runnableRunDelayed(new Runnable() {

        public void run() {
            EditSubkeyExpiryDialogFragment dialogFragment = EditSubkeyExpiryDialogFragment.newInstance(messenger, creationDate, expiryDate);
            dialogFragment.show(getActivity().getSupportFragmentManager(), "editSubkeyExpiryDialog");
        }
    });
}