539 lines
23 KiB
Java
539 lines
23 KiB
Java
/*
|
|
* Copyright (C) 2012-2013 Dominik Schürmann <dominik@dominikschuermann.de>
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
package org.sufficientlysecure.keychain.ui.dialog;
|
|
|
|
import android.annotation.TargetApi;
|
|
import android.app.Dialog;
|
|
import android.os.Build;
|
|
import android.os.Bundle;
|
|
import android.support.v4.app.DialogFragment;
|
|
import android.support.v4.app.FragmentActivity;
|
|
import android.support.v7.app.AlertDialog;
|
|
import android.text.Editable;
|
|
import android.text.TextWatcher;
|
|
import android.view.LayoutInflater;
|
|
import android.view.View;
|
|
import android.view.inputmethod.InputMethodManager;
|
|
import android.widget.AdapterView;
|
|
import android.widget.ArrayAdapter;
|
|
import android.widget.Button;
|
|
import android.widget.CheckBox;
|
|
import android.widget.CompoundButton;
|
|
import android.widget.DatePicker;
|
|
import android.widget.EditText;
|
|
import android.widget.Spinner;
|
|
import android.widget.TableRow;
|
|
import android.widget.TextView;
|
|
import android.widget.Toast;
|
|
|
|
import org.bouncycastle.bcpg.sig.KeyFlags;
|
|
import org.sufficientlysecure.keychain.R;
|
|
import org.sufficientlysecure.keychain.service.SaveKeyringParcel;
|
|
import org.sufficientlysecure.keychain.service.SaveKeyringParcel.Algorithm;
|
|
import org.sufficientlysecure.keychain.service.SaveKeyringParcel.Curve;
|
|
import org.sufficientlysecure.keychain.util.Choice;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Calendar;
|
|
import java.util.TimeZone;
|
|
|
|
public class AddSubkeyDialogFragment extends DialogFragment {
|
|
|
|
public interface OnAlgorithmSelectedListener {
|
|
public void onAlgorithmSelected(SaveKeyringParcel.SubkeyAdd newSubkey);
|
|
}
|
|
|
|
private static final String ARG_WILL_BE_MASTER_KEY = "will_be_master_key";
|
|
|
|
private OnAlgorithmSelectedListener mAlgorithmSelectedListener;
|
|
|
|
private CheckBox mNoExpiryCheckBox;
|
|
private TableRow mExpiryRow;
|
|
private DatePicker mExpiryDatePicker;
|
|
private Spinner mAlgorithmSpinner;
|
|
private View mKeySizeRow;
|
|
private Spinner mKeySizeSpinner;
|
|
private View mCurveRow;
|
|
private Spinner mCurveSpinner;
|
|
private TextView mCustomKeyTextView;
|
|
private EditText mCustomKeyEditText;
|
|
private TextView mCustomKeyInfoTextView;
|
|
private CheckBox mFlagCertify;
|
|
private CheckBox mFlagSign;
|
|
private CheckBox mFlagEncrypt;
|
|
private CheckBox mFlagAuthenticate;
|
|
|
|
private boolean mWillBeMasterKey;
|
|
|
|
public void setOnAlgorithmSelectedListener(OnAlgorithmSelectedListener listener) {
|
|
mAlgorithmSelectedListener = listener;
|
|
}
|
|
|
|
public static AddSubkeyDialogFragment newInstance(boolean willBeMasterKey) {
|
|
AddSubkeyDialogFragment frag = new AddSubkeyDialogFragment();
|
|
Bundle args = new Bundle();
|
|
|
|
args.putBoolean(ARG_WILL_BE_MASTER_KEY, willBeMasterKey);
|
|
|
|
frag.setArguments(args);
|
|
|
|
return frag;
|
|
}
|
|
|
|
@Override
|
|
public Dialog onCreateDialog(Bundle savedInstanceState) {
|
|
final FragmentActivity context = getActivity();
|
|
final LayoutInflater mInflater;
|
|
|
|
mWillBeMasterKey = getArguments().getBoolean(ARG_WILL_BE_MASTER_KEY);
|
|
mInflater = context.getLayoutInflater();
|
|
|
|
CustomAlertDialogBuilder dialog = new CustomAlertDialogBuilder(context);
|
|
|
|
View view = mInflater.inflate(R.layout.add_subkey_dialog, null);
|
|
dialog.setView(view);
|
|
dialog.setTitle(R.string.title_add_subkey);
|
|
|
|
mNoExpiryCheckBox = (CheckBox) view.findViewById(R.id.add_subkey_no_expiry);
|
|
mExpiryRow = (TableRow) view.findViewById(R.id.add_subkey_expiry_row);
|
|
mExpiryDatePicker = (DatePicker) view.findViewById(R.id.add_subkey_expiry_date_picker);
|
|
mAlgorithmSpinner = (Spinner) view.findViewById(R.id.add_subkey_algorithm);
|
|
mKeySizeSpinner = (Spinner) view.findViewById(R.id.add_subkey_size);
|
|
mCurveSpinner = (Spinner) view.findViewById(R.id.add_subkey_curve);
|
|
mKeySizeRow = view.findViewById(R.id.add_subkey_row_size);
|
|
mCurveRow = view.findViewById(R.id.add_subkey_row_curve);
|
|
mCustomKeyTextView = (TextView) view.findViewById(R.id.add_subkey_custom_key_size_label);
|
|
mCustomKeyEditText = (EditText) view.findViewById(R.id.add_subkey_custom_key_size_input);
|
|
mCustomKeyInfoTextView = (TextView) view.findViewById(R.id.add_subkey_custom_key_size_info);
|
|
mFlagCertify = (CheckBox) view.findViewById(R.id.add_subkey_flag_certify);
|
|
mFlagSign = (CheckBox) view.findViewById(R.id.add_subkey_flag_sign);
|
|
mFlagEncrypt = (CheckBox) view.findViewById(R.id.add_subkey_flag_encrypt);
|
|
mFlagAuthenticate = (CheckBox) view.findViewById(R.id.add_subkey_flag_authenticate);
|
|
|
|
mNoExpiryCheckBox.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
|
|
@Override
|
|
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
|
|
if (isChecked) {
|
|
mExpiryRow.setVisibility(View.GONE);
|
|
} else {
|
|
mExpiryRow.setVisibility(View.VISIBLE);
|
|
}
|
|
}
|
|
});
|
|
|
|
// date picker works based on default time zone
|
|
Calendar minDateCal = Calendar.getInstance(TimeZone.getDefault());
|
|
minDateCal.add(Calendar.DAY_OF_YEAR, 1); // at least one day after creation (today)
|
|
mExpiryDatePicker.setMinDate(minDateCal.getTime().getTime());
|
|
|
|
{
|
|
ArrayList<Choice<Algorithm>> choices = new ArrayList<>();
|
|
choices.add(new Choice<>(Algorithm.DSA, getResources().getString(
|
|
R.string.dsa)));
|
|
if (!mWillBeMasterKey) {
|
|
choices.add(new Choice<>(Algorithm.ELGAMAL, getResources().getString(
|
|
R.string.elgamal)));
|
|
}
|
|
choices.add(new Choice<>(Algorithm.RSA, getResources().getString(
|
|
R.string.rsa)));
|
|
choices.add(new Choice<>(Algorithm.ECDSA, getResources().getString(
|
|
R.string.ecdsa)));
|
|
choices.add(new Choice<>(Algorithm.ECDH, getResources().getString(
|
|
R.string.ecdh)));
|
|
ArrayAdapter<Choice<Algorithm>> adapter = new ArrayAdapter<>(context,
|
|
android.R.layout.simple_spinner_item, choices);
|
|
adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
|
|
mAlgorithmSpinner.setAdapter(adapter);
|
|
// make RSA the default
|
|
for (int i = 0; i < choices.size(); ++i) {
|
|
if (choices.get(i).getId() == Algorithm.RSA) {
|
|
mAlgorithmSpinner.setSelection(i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// dynamic ArrayAdapter must be created (instead of ArrayAdapter.getFromResource), because it's content may change
|
|
ArrayAdapter<CharSequence> keySizeAdapter = new ArrayAdapter<>(context, android.R.layout.simple_spinner_item,
|
|
new ArrayList<CharSequence>(Arrays.asList(getResources().getStringArray(R.array.rsa_key_size_spinner_values))));
|
|
keySizeAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
|
|
mKeySizeSpinner.setAdapter(keySizeAdapter);
|
|
mKeySizeSpinner.setSelection(1); // Default to 4096 for the key length
|
|
|
|
{
|
|
ArrayList<Choice<Curve>> choices = new ArrayList<>();
|
|
|
|
choices.add(new Choice<>(Curve.NIST_P256, getResources().getString(
|
|
R.string.key_curve_nist_p256)));
|
|
choices.add(new Choice<>(Curve.NIST_P384, getResources().getString(
|
|
R.string.key_curve_nist_p384)));
|
|
choices.add(new Choice<>(Curve.NIST_P521, getResources().getString(
|
|
R.string.key_curve_nist_p521)));
|
|
|
|
/* @see SaveKeyringParcel
|
|
choices.add(new Choice<Curve>(Curve.BRAINPOOL_P256, getResources().getString(
|
|
R.string.key_curve_bp_p256)));
|
|
choices.add(new Choice<Curve>(Curve.BRAINPOOL_P384, getResources().getString(
|
|
R.string.key_curve_bp_p384)));
|
|
choices.add(new Choice<Curve>(Curve.BRAINPOOL_P512, getResources().getString(
|
|
R.string.key_curve_bp_p512)));
|
|
*/
|
|
|
|
ArrayAdapter<Choice<Curve>> adapter = new ArrayAdapter<>(context,
|
|
android.R.layout.simple_spinner_item, choices);
|
|
mCurveSpinner.setAdapter(adapter);
|
|
// make NIST P-256 the default
|
|
for (int i = 0; i < choices.size(); ++i) {
|
|
if (choices.get(i).getId() == Curve.NIST_P256) {
|
|
mCurveSpinner.setSelection(i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
dialog.setCancelable(true);
|
|
|
|
// onClickListener are set in onStart() to override default dismiss behaviour
|
|
dialog.setPositiveButton(android.R.string.ok, null);
|
|
dialog.setNegativeButton(android.R.string.cancel, null);
|
|
|
|
final AlertDialog alertDialog = dialog.show();
|
|
|
|
mCustomKeyEditText.addTextChangedListener(new TextWatcher() {
|
|
@Override
|
|
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
|
|
}
|
|
|
|
@Override
|
|
public void onTextChanged(CharSequence s, int start, int before, int count) {
|
|
}
|
|
|
|
@Override
|
|
public void afterTextChanged(Editable s) {
|
|
setOkButtonAvailability(alertDialog);
|
|
}
|
|
});
|
|
|
|
mKeySizeSpinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
|
|
@Override
|
|
public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
|
|
setCustomKeyVisibility();
|
|
setOkButtonAvailability(alertDialog);
|
|
}
|
|
|
|
@Override
|
|
public void onNothingSelected(AdapterView<?> parent) {
|
|
}
|
|
});
|
|
|
|
mAlgorithmSpinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
|
|
@Override
|
|
public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
|
|
updateUiForAlgorithm(((Choice<Algorithm>) parent.getSelectedItem()).getId());
|
|
|
|
setCustomKeyVisibility();
|
|
setOkButtonAvailability(alertDialog);
|
|
}
|
|
|
|
@Override
|
|
public void onNothingSelected(AdapterView<?> parent) {
|
|
}
|
|
});
|
|
|
|
return alertDialog;
|
|
}
|
|
|
|
@Override
|
|
public void onStart() {
|
|
super.onStart(); //super.onStart() is where dialog.show() is actually called on the underlying dialog, so we have to do it after this point
|
|
AlertDialog d = (AlertDialog) getDialog();
|
|
if (d != null) {
|
|
Button positiveButton = d.getButton(Dialog.BUTTON_POSITIVE);
|
|
Button negativeButton = d.getButton(Dialog.BUTTON_NEGATIVE);
|
|
positiveButton.setOnClickListener(new View.OnClickListener() {
|
|
@Override
|
|
public void onClick(View v) {
|
|
if (!mFlagCertify.isChecked() && !mFlagSign.isChecked()
|
|
&& !mFlagEncrypt.isChecked() && !mFlagAuthenticate.isChecked()) {
|
|
Toast.makeText(getActivity(), R.string.edit_key_select_flag, Toast.LENGTH_LONG).show();
|
|
return;
|
|
}
|
|
|
|
Algorithm algorithm = ((Choice<Algorithm>) mAlgorithmSpinner.getSelectedItem()).getId();
|
|
Curve curve = null;
|
|
Integer keySize = null;
|
|
// For EC keys, add a curve
|
|
if (algorithm == Algorithm.ECDH || algorithm == Algorithm.ECDSA) {
|
|
curve = ((Choice<Curve>) mCurveSpinner.getSelectedItem()).getId();
|
|
// Otherwise, get a keysize
|
|
} else {
|
|
keySize = getProperKeyLength(algorithm, getSelectedKeyLength());
|
|
}
|
|
|
|
int flags = 0;
|
|
if (mFlagCertify.isChecked()) {
|
|
flags |= KeyFlags.CERTIFY_OTHER;
|
|
}
|
|
if (mFlagSign.isChecked()) {
|
|
flags |= KeyFlags.SIGN_DATA;
|
|
}
|
|
if (mFlagEncrypt.isChecked()) {
|
|
flags |= KeyFlags.ENCRYPT_COMMS | KeyFlags.ENCRYPT_STORAGE;
|
|
}
|
|
if (mFlagAuthenticate.isChecked()) {
|
|
flags |= KeyFlags.AUTHENTICATION;
|
|
}
|
|
|
|
long expiry;
|
|
if (mNoExpiryCheckBox.isChecked()) {
|
|
expiry = 0L;
|
|
} else {
|
|
Calendar selectedCal = Calendar.getInstance(TimeZone.getDefault());
|
|
//noinspection ResourceType
|
|
selectedCal.set(mExpiryDatePicker.getYear(),
|
|
mExpiryDatePicker.getMonth(), mExpiryDatePicker.getDayOfMonth());
|
|
// date picker uses default time zone, we need to convert to UTC
|
|
selectedCal.setTimeZone(TimeZone.getTimeZone("UTC"));
|
|
|
|
expiry = selectedCal.getTime().getTime() / 1000;
|
|
}
|
|
|
|
SaveKeyringParcel.SubkeyAdd newSubkey = new SaveKeyringParcel.SubkeyAdd(
|
|
algorithm, keySize, curve, flags, expiry
|
|
);
|
|
mAlgorithmSelectedListener.onAlgorithmSelected(newSubkey);
|
|
|
|
// finally, dismiss the dialogue
|
|
dismiss();
|
|
}
|
|
});
|
|
negativeButton.setOnClickListener(new View.OnClickListener() {
|
|
@Override
|
|
public void onClick(View v) {
|
|
dismiss();
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
private int getSelectedKeyLength() {
|
|
final String selectedItemString = (String) mKeySizeSpinner.getSelectedItem();
|
|
final String customLengthString = getResources().getString(R.string.key_size_custom);
|
|
final boolean customSelected = customLengthString.equals(selectedItemString);
|
|
String keyLengthString = customSelected ? mCustomKeyEditText.getText().toString() : selectedItemString;
|
|
int keySize;
|
|
try {
|
|
keySize = Integer.parseInt(keyLengthString);
|
|
} catch (NumberFormatException e) {
|
|
keySize = 0;
|
|
}
|
|
return keySize;
|
|
}
|
|
|
|
/**
|
|
* <h3>RSA</h3>
|
|
* <p>for RSA algorithm, key length must be greater than 2048. Possibility to generate keys bigger
|
|
* than 8192 bits is currently disabled, because it's almost impossible to generate them on a mobile device (check
|
|
* <a href="http://www.javamex.com/tutorials/cryptography/rsa_key_length.shtml">RSA key length plot</a> and
|
|
* <a href="http://www.keylength.com/">Cryptographic Key Length Recommendation</a>). Also, key length must be a
|
|
* multiplicity of 8.</p>
|
|
* <h3>ElGamal</h3>
|
|
* <p>For ElGamal algorithm, supported key lengths are 2048, 3072, 4096 or 8192 bits.</p>
|
|
* <h3>DSA</h3>
|
|
* <p>For DSA algorithm key length must be between 2048 and 3072. Also, it must me dividable by 64.</p>
|
|
*
|
|
* @return correct key length, according to SpongyCastle specification. Returns <code>-1</code>, if key length is
|
|
* inappropriate.
|
|
*/
|
|
private int getProperKeyLength(Algorithm algorithm, int currentKeyLength) {
|
|
final int[] elGamalSupportedLengths = {2048, 3072, 4096, 8192};
|
|
int properKeyLength = -1;
|
|
switch (algorithm) {
|
|
case RSA: {
|
|
if (currentKeyLength >= 2048 && currentKeyLength <= 16384) {
|
|
properKeyLength = currentKeyLength + ((8 - (currentKeyLength % 8)) % 8);
|
|
}
|
|
break;
|
|
}
|
|
case ELGAMAL: {
|
|
int[] elGammalKeyDiff = new int[elGamalSupportedLengths.length];
|
|
for (int i = 0; i < elGamalSupportedLengths.length; i++) {
|
|
elGammalKeyDiff[i] = Math.abs(elGamalSupportedLengths[i] - currentKeyLength);
|
|
}
|
|
int minimalValue = Integer.MAX_VALUE;
|
|
int minimalIndex = -1;
|
|
for (int i = 0; i < elGammalKeyDiff.length; i++) {
|
|
if (elGammalKeyDiff[i] <= minimalValue) {
|
|
minimalValue = elGammalKeyDiff[i];
|
|
minimalIndex = i;
|
|
}
|
|
}
|
|
properKeyLength = elGamalSupportedLengths[minimalIndex];
|
|
break;
|
|
}
|
|
case DSA: {
|
|
// Bouncy Castle supports 4096 maximum
|
|
if (currentKeyLength >= 2048 && currentKeyLength <= 4096) {
|
|
properKeyLength = currentKeyLength + ((64 - (currentKeyLength % 64)) % 64);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return properKeyLength;
|
|
}
|
|
|
|
private void setOkButtonAvailability(AlertDialog alertDialog) {
|
|
Algorithm algorithm = ((Choice<Algorithm>) mAlgorithmSpinner.getSelectedItem()).getId();
|
|
boolean enabled = algorithm == Algorithm.ECDSA || algorithm == Algorithm.ECDH
|
|
|| getProperKeyLength(algorithm, getSelectedKeyLength()) > 0;
|
|
alertDialog.getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(enabled);
|
|
}
|
|
|
|
private void setCustomKeyVisibility() {
|
|
final String selectedItemString = (String) mKeySizeSpinner.getSelectedItem();
|
|
final String customLengthString = getResources().getString(R.string.key_size_custom);
|
|
final boolean customSelected = customLengthString.equals(selectedItemString);
|
|
final int visibility = customSelected ? View.VISIBLE : View.GONE;
|
|
|
|
mCustomKeyEditText.setVisibility(visibility);
|
|
mCustomKeyTextView.setVisibility(visibility);
|
|
mCustomKeyInfoTextView.setVisibility(visibility);
|
|
|
|
// hide keyboard after setting visibility to gone
|
|
if (visibility == View.GONE) {
|
|
InputMethodManager imm = (InputMethodManager)
|
|
getActivity().getSystemService(FragmentActivity.INPUT_METHOD_SERVICE);
|
|
imm.hideSoftInputFromWindow(mCustomKeyEditText.getWindowToken(), 0);
|
|
}
|
|
}
|
|
|
|
private void updateUiForAlgorithm(Algorithm algorithm) {
|
|
final ArrayAdapter<CharSequence> keySizeAdapter = (ArrayAdapter<CharSequence>) mKeySizeSpinner.getAdapter();
|
|
keySizeAdapter.clear();
|
|
switch (algorithm) {
|
|
case RSA: {
|
|
replaceArrayAdapterContent(keySizeAdapter, R.array.rsa_key_size_spinner_values);
|
|
mKeySizeSpinner.setSelection(1);
|
|
mKeySizeRow.setVisibility(View.VISIBLE);
|
|
mCurveRow.setVisibility(View.GONE);
|
|
mCustomKeyInfoTextView.setText(getResources().getString(R.string.key_size_custom_info_rsa));
|
|
// allowed flags:
|
|
mFlagSign.setEnabled(true);
|
|
mFlagEncrypt.setEnabled(true);
|
|
mFlagAuthenticate.setEnabled(true);
|
|
|
|
if (mWillBeMasterKey) {
|
|
mFlagCertify.setEnabled(true);
|
|
|
|
mFlagCertify.setChecked(true);
|
|
mFlagSign.setChecked(false);
|
|
mFlagEncrypt.setChecked(false);
|
|
} else {
|
|
mFlagCertify.setEnabled(false);
|
|
|
|
mFlagCertify.setChecked(false);
|
|
mFlagSign.setChecked(true);
|
|
mFlagEncrypt.setChecked(true);
|
|
}
|
|
mFlagAuthenticate.setChecked(false);
|
|
break;
|
|
}
|
|
case ELGAMAL: {
|
|
replaceArrayAdapterContent(keySizeAdapter, R.array.elgamal_key_size_spinner_values);
|
|
mKeySizeSpinner.setSelection(3);
|
|
mKeySizeRow.setVisibility(View.VISIBLE);
|
|
mCurveRow.setVisibility(View.GONE);
|
|
mCustomKeyInfoTextView.setText(""); // ElGamal does not support custom key length
|
|
// allowed flags:
|
|
mFlagCertify.setChecked(false);
|
|
mFlagCertify.setEnabled(false);
|
|
mFlagSign.setChecked(false);
|
|
mFlagSign.setEnabled(false);
|
|
mFlagEncrypt.setChecked(true);
|
|
mFlagEncrypt.setEnabled(true);
|
|
mFlagAuthenticate.setChecked(false);
|
|
mFlagAuthenticate.setEnabled(false);
|
|
break;
|
|
}
|
|
case DSA: {
|
|
replaceArrayAdapterContent(keySizeAdapter, R.array.dsa_key_size_spinner_values);
|
|
mKeySizeSpinner.setSelection(2);
|
|
mKeySizeRow.setVisibility(View.VISIBLE);
|
|
mCurveRow.setVisibility(View.GONE);
|
|
mCustomKeyInfoTextView.setText(getResources().getString(R.string.key_size_custom_info_dsa));
|
|
// allowed flags:
|
|
mFlagCertify.setChecked(false);
|
|
mFlagCertify.setEnabled(false);
|
|
mFlagSign.setChecked(true);
|
|
mFlagSign.setEnabled(true);
|
|
mFlagEncrypt.setChecked(false);
|
|
mFlagEncrypt.setEnabled(false);
|
|
mFlagAuthenticate.setChecked(false);
|
|
mFlagAuthenticate.setEnabled(false);
|
|
break;
|
|
}
|
|
case ECDSA: {
|
|
mKeySizeRow.setVisibility(View.GONE);
|
|
mCurveRow.setVisibility(View.VISIBLE);
|
|
mCustomKeyInfoTextView.setText("");
|
|
// allowed flags:
|
|
mFlagCertify.setEnabled(mWillBeMasterKey);
|
|
mFlagCertify.setChecked(mWillBeMasterKey);
|
|
mFlagSign.setEnabled(true);
|
|
mFlagSign.setChecked(!mWillBeMasterKey);
|
|
mFlagEncrypt.setEnabled(false);
|
|
mFlagEncrypt.setChecked(false);
|
|
mFlagAuthenticate.setEnabled(true);
|
|
mFlagAuthenticate.setChecked(false);
|
|
break;
|
|
}
|
|
case ECDH: {
|
|
mKeySizeRow.setVisibility(View.GONE);
|
|
mCurveRow.setVisibility(View.VISIBLE);
|
|
mCustomKeyInfoTextView.setText("");
|
|
// allowed flags:
|
|
mFlagCertify.setChecked(false);
|
|
mFlagCertify.setEnabled(false);
|
|
mFlagSign.setChecked(false);
|
|
mFlagSign.setEnabled(false);
|
|
mFlagEncrypt.setChecked(true);
|
|
mFlagEncrypt.setEnabled(true);
|
|
mFlagAuthenticate.setChecked(false);
|
|
mFlagAuthenticate.setEnabled(false);
|
|
break;
|
|
}
|
|
}
|
|
keySizeAdapter.notifyDataSetChanged();
|
|
|
|
}
|
|
|
|
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
|
|
private void replaceArrayAdapterContent(ArrayAdapter<CharSequence> arrayAdapter, int stringArrayResourceId) {
|
|
final String[] spinnerValuesStringArray = getResources().getStringArray(stringArrayResourceId);
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
|
|
arrayAdapter.addAll(spinnerValuesStringArray);
|
|
} else {
|
|
for (final String value : spinnerValuesStringArray) {
|
|
arrayAdapter.add(value);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|