From 92b8d874ed0d7e8f835dbd8ce4205e74841d7162 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Thu, 15 Jan 2015 16:59:11 +0100 Subject: affirmation -> linked identity --- .../ui/linked/LinkedIdCreateDnsStep1Fragment.java | 133 ++++++++ .../ui/linked/LinkedIdCreateDnsStep2Fragment.java | 360 ++++++++++++++++++++ .../linked/LinkedIdCreateHttpsStep1Fragment.java | 132 ++++++++ .../linked/LinkedIdCreateHttpsStep2Fragment.java | 366 +++++++++++++++++++++ .../linked/LinkedIdCreateTwitterStep1Fragment.java | 134 ++++++++ .../linked/LinkedIdCreateTwitterStep2Fragment.java | 149 +++++++++ .../linked/LinkedIdCreateTwitterStep3Fragment.java | 235 +++++++++++++ .../keychain/ui/linked/LinkedIdSelectFragment.java | 91 +++++ .../keychain/ui/linked/LinkedIdWizard.java | 98 ++++++ 9 files changed, 1698 insertions(+) create mode 100644 OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java create mode 100644 OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java create mode 100644 OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java create mode 100644 OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java create mode 100644 OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java create mode 100644 OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java create mode 100644 OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java create mode 100644 OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdSelectFragment.java create mode 100644 OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdWizard.java (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java new file mode 100644 index 000000000..ba57ace4b --- /dev/null +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java @@ -0,0 +1,133 @@ +/* + * Copyright (C) 2014 Dominik Schürmann + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package org.sufficientlysecure.keychain.ui.linked; + +import android.os.Bundle; +import android.support.v4.app.Fragment; +import android.text.Editable; +import android.text.TextWatcher; +import android.util.Patterns; +import android.view.LayoutInflater; +import android.view.View; +import android.view.View.OnClickListener; +import android.view.ViewGroup; +import android.widget.EditText; + +import org.sufficientlysecure.keychain.R; +import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; +import org.sufficientlysecure.keychain.pgp.linked.resources.DnsResource; + +public class LinkedIdCreateDnsStep1Fragment extends Fragment { + + LinkedIdWizard mLinkedIdWizard; + + EditText mEditDns; + + /** + * Creates new instance of this fragment + */ + public static LinkedIdCreateDnsStep1Fragment newInstance() { + LinkedIdCreateDnsStep1Fragment frag = new LinkedIdCreateDnsStep1Fragment(); + + Bundle args = new Bundle(); + frag.setArguments(args); + + return frag; + } + + @Override + public void onActivityCreated(Bundle savedInstanceState) { + super.onActivityCreated(savedInstanceState); + + mLinkedIdWizard = (LinkedIdWizard) getActivity(); + + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + final View view = inflater.inflate(R.layout.linked_create_dns_fragment_step1, container, false); + + view.findViewById(R.id.next_button).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + + String uri = mEditDns.getText().toString(); + + if (!checkUri(uri)) { + mEditDns.setError("Please enter a valid domain name!"); + return; + } + + String proofNonce = LinkedIdentity.generateNonce(); + String proofText = DnsResource.generateText(getActivity(), + mLinkedIdWizard.mFingerprint, proofNonce); + + LinkedIdCreateDnsStep2Fragment frag = + LinkedIdCreateDnsStep2Fragment.newInstance(uri, proofNonce, proofText); + + mLinkedIdWizard.loadFragment(null, frag, LinkedIdWizard.FRAG_ACTION_TO_RIGHT); + + } + }); + + view.findViewById(R.id.back_button).setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + mLinkedIdWizard.loadFragment(null, null, LinkedIdWizard.FRAG_ACTION_TO_LEFT); + } + }); + + mEditDns = (EditText) view.findViewById(R.id.linked_create_dns_domain); + + mEditDns.addTextChangedListener(new TextWatcher() { + @Override + public void beforeTextChanged(CharSequence charSequence, int i, int i2, int i3) { + } + + @Override + public void onTextChanged(CharSequence charSequence, int i, int i2, int i3) { + } + + @Override + public void afterTextChanged(Editable editable) { + String uri = editable.toString(); + if (uri.length() > 0) { + if (checkUri(uri)) { + mEditDns.setCompoundDrawablesWithIntrinsicBounds(0, 0, + R.drawable.uid_mail_ok, 0); + } else { + mEditDns.setCompoundDrawablesWithIntrinsicBounds(0, 0, + R.drawable.uid_mail_bad, 0); + } + } else { + // remove drawable if email is empty + mEditDns.setCompoundDrawablesWithIntrinsicBounds(0, 0, 0, 0); + } + } + }); + + mEditDns.setText("mugenguild.com"); + + return view; + } + + private static boolean checkUri(String uri) { + return Patterns.DOMAIN_NAME.matcher(uri).matches(); + } + +} diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java new file mode 100644 index 000000000..ff8d03dd4 --- /dev/null +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java @@ -0,0 +1,360 @@ +/* + * Copyright (C) 2014 Dominik Schürmann + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package org.sufficientlysecure.keychain.ui.linked; + +import android.app.Activity; +import android.app.ProgressDialog; +import android.content.Intent; +import android.graphics.PorterDuff; +import android.net.Uri; +import android.os.AsyncTask; +import android.os.Build; +import android.os.Bundle; +import android.os.Environment; +import android.os.Message; +import android.os.Messenger; +import android.support.v4.app.Fragment; +import android.view.LayoutInflater; +import android.view.View; +import android.view.View.OnClickListener; +import android.view.ViewGroup; +import android.widget.EditText; +import android.widget.ImageView; +import android.widget.TextView; + +import org.sufficientlysecure.keychain.Constants; +import org.sufficientlysecure.keychain.R; +import org.sufficientlysecure.keychain.operations.results.LinkedVerifyResult; +import org.sufficientlysecure.keychain.operations.results.OperationResult; +import org.sufficientlysecure.keychain.pgp.WrappedUserAttribute; +import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; +import org.sufficientlysecure.keychain.pgp.linked.resources.DnsResource; +import org.sufficientlysecure.keychain.service.KeychainIntentService; +import org.sufficientlysecure.keychain.service.KeychainIntentServiceHandler; +import org.sufficientlysecure.keychain.service.SaveKeyringParcel; +import org.sufficientlysecure.keychain.ui.PassphraseDialogActivity; +import org.sufficientlysecure.keychain.ui.util.Notify; +import org.sufficientlysecure.keychain.ui.util.Notify.Style; +import org.sufficientlysecure.keychain.util.FileHelper; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.PrintWriter; + +public class LinkedIdCreateDnsStep2Fragment extends Fragment { + + private static final int REQUEST_CODE_OUTPUT = 0x00007007; + private static final int REQUEST_CODE_PASSPHRASE = 0x00007008; + + public static final String DOMAIN = "domain", NONCE = "nonce", TEXT = "text"; + + LinkedIdWizard mLinkedIdWizard; + + EditText mEditUri; + ImageView mVerifyImage; + View mVerifyProgress; + TextView mVerifyStatus; + + String mResourceDomain; + String mResourceNonce, mResourceString; + + // This is a resource, set AFTER it has been verified + DnsResource mVerifiedResource = null; + + /** + * Creates new instance of this fragment + */ + public static LinkedIdCreateDnsStep2Fragment newInstance + (String uri, String proofNonce, String proofText) { + + LinkedIdCreateDnsStep2Fragment frag = new LinkedIdCreateDnsStep2Fragment(); + + Bundle args = new Bundle(); + args.putString(DOMAIN, uri); + args.putString(NONCE, proofNonce); + args.putString(TEXT, proofText); + frag.setArguments(args); + + return frag; + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + final View view = inflater.inflate(R.layout.linked_create_dns_fragment_step2, container, false); + + mResourceDomain = getArguments().getString(DOMAIN); + mResourceNonce = getArguments().getString(NONCE); + mResourceString = getArguments().getString(TEXT); + + view.findViewById(R.id.next_button).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + startCertify(); + } + }); + + view.findViewById(R.id.back_button).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + mLinkedIdWizard.loadFragment(null, null, LinkedIdWizard.FRAG_ACTION_TO_LEFT); + } + }); + + mVerifyImage = (ImageView) view.findViewById(R.id.verify_image); + mVerifyProgress = view.findViewById(R.id.verify_progress); + mVerifyStatus = (TextView) view.findViewById(R.id.verify_status); + + view.findViewById(R.id.button_send).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + proofSend(); + } + }); + + view.findViewById(R.id.button_save).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + proofSave(); + } + }); + + view.findViewById(R.id.button_verify).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + proofVerify(); + } + }); + + mEditUri = (EditText) view.findViewById(R.id.linked_create_dns_text); + mEditUri.setText(mResourceString); + + setVerifyProgress(false, null); + mVerifyStatus.setText(R.string.linked_verify_pending); + + return view; + } + + @Override + public void onActivityCreated(Bundle savedInstanceState) { + super.onActivityCreated(savedInstanceState); + + mLinkedIdWizard = (LinkedIdWizard) getActivity(); + } + + public void setVerifyProgress(boolean on, Boolean success) { + mVerifyProgress.setVisibility(on ? View.VISIBLE : View.GONE); + mVerifyImage.setVisibility(on ? View.GONE : View.VISIBLE); + if (success == null) { + mVerifyStatus.setText(R.string.linked_verifying); + mVerifyImage.setImageResource(R.drawable.status_signature_unverified_cutout); + mVerifyImage.setColorFilter(getResources().getColor(R.color.tertiary_text_light), + PorterDuff.Mode.SRC_IN); + } else if (success) { + mVerifyStatus.setText(R.string.linked_verify_success); + mVerifyImage.setImageResource(R.drawable.status_signature_verified_cutout); + mVerifyImage.setColorFilter(getResources().getColor(R.color.android_green_dark), + PorterDuff.Mode.SRC_IN); + } else { + mVerifyStatus.setText(R.string.linked_verify_error); + mVerifyImage.setImageResource(R.drawable.status_signature_unknown_cutout); + mVerifyImage.setColorFilter(getResources().getColor(R.color.android_red_dark), + PorterDuff.Mode.SRC_IN); + } + } + + private void proofSend () { + Intent sendIntent = new Intent(); + sendIntent.setAction(Intent.ACTION_SEND); + sendIntent.putExtra(Intent.EXTRA_TEXT, mResourceString); + sendIntent.setType("text/plain"); + startActivity(sendIntent); + } + + private void proofSave () { + String state = Environment.getExternalStorageState(); + if (!Environment.MEDIA_MOUNTED.equals(state)) { + Notify.showNotify(getActivity(), "External storage not available!", Style.ERROR); + return; + } + + String targetName = "pgpkey.txt"; + + if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) { + File targetFile = new File(Constants.Path.APP_DIR, targetName); + FileHelper.saveFile(this, getString(R.string.title_decrypt_to_file), + getString(R.string.specify_file_to_decrypt_to), targetFile, REQUEST_CODE_OUTPUT); + } else { + FileHelper.saveDocument(this, "text/plain", targetName, REQUEST_CODE_OUTPUT); + } + } + + private void saveFile(Uri uri) { + try { + PrintWriter out = + new PrintWriter(getActivity().getContentResolver().openOutputStream(uri)); + out.print(mResourceString); + if (out.checkError()) { + Notify.showNotify(getActivity(), "Error writing file!", Style.ERROR); + } + } catch (FileNotFoundException e) { + Notify.showNotify(getActivity(), "File could not be opened for writing!", Style.ERROR); + e.printStackTrace(); + } + } + + public void proofVerify() { + setVerifyProgress(true, null); + + final DnsResource resource = DnsResource.createNew(mResourceDomain); + + new AsyncTask() { + + @Override + protected LinkedVerifyResult doInBackground(Void... params) { + return resource.verify(mLinkedIdWizard.mFingerprint, mResourceNonce); + } + + @Override + protected void onPostExecute(LinkedVerifyResult result) { + super.onPostExecute(result); + if (result.success()) { + setVerifyProgress(false, true); + mVerifiedResource = resource; + } else { + setVerifyProgress(false, false); + // on error, show error message + result.createNotify(getActivity()).show(); + } + } + }.execute(); + + } + + public void startCertify() { + + if (mVerifiedResource == null) { + Notify.showNotify(getActivity(), R.string.linked_need_verify, Style.ERROR); + return; + } + + Intent intent = new Intent(getActivity(), PassphraseDialogActivity.class); + intent.putExtra(PassphraseDialogActivity.EXTRA_SUBKEY_ID, mLinkedIdWizard.mMasterKeyId); + startActivityForResult(intent, REQUEST_CODE_PASSPHRASE); + + } + + public void certifyLinkedIdentity (String passphrase) { + KeychainIntentServiceHandler saveHandler = new KeychainIntentServiceHandler( + getActivity(), + getString(R.string.progress_saving), + ProgressDialog.STYLE_HORIZONTAL, + true) { + public void handleMessage(Message message) { + // handle messages by standard KeychainIntentServiceHandler first + super.handleMessage(message); + + if (message.arg1 == KeychainIntentServiceHandler.MESSAGE_OKAY) { + + // get returned data bundle + Bundle returnData = message.getData(); + if (returnData == null) { + return; + } + final OperationResult result = + returnData.getParcelable(OperationResult.EXTRA_RESULT); + if (result == null) { + return; + } + + // if bad -> display here! + if (!result.success()) { + result.createNotify(getActivity()).show(); + return; + } + + result.createNotify(getActivity()).show(); + + // if good -> finish, return result to showkey and display there! + // Intent intent = new Intent(); + // intent.putExtra(OperationResult.EXTRA_RESULT, result); + // getActivity().setResult(EditKeyActivity.RESULT_OK, intent); + + // AffirmationCreateHttpsStep3Fragment frag = + // AffirmationCreateHttpsStep3Fragment.newInstance( + // mResourceDomain, mResourceNonce, mResourceString); + + // mAffirmationWizard.loadFragment(null, frag, AffirmationWizard.FRAG_ACTION_TO_RIGHT); + + } + } + }; + + SaveKeyringParcel skp = + new SaveKeyringParcel(mLinkedIdWizard.mMasterKeyId, mLinkedIdWizard.mFingerprint); + + WrappedUserAttribute ua = + LinkedIdentity.fromResource(mVerifiedResource, mResourceNonce).toUserAttribute(); + + skp.mAddUserAttribute.add(ua); + + // Send all information needed to service to import key in other thread + Intent intent = new Intent(getActivity(), KeychainIntentService.class); + intent.setAction(KeychainIntentService.ACTION_EDIT_KEYRING); + + // fill values for this action + Bundle data = new Bundle(); + data.putString(KeychainIntentService.EDIT_KEYRING_PASSPHRASE, passphrase); + data.putParcelable(KeychainIntentService.EDIT_KEYRING_PARCEL, skp); + intent.putExtra(KeychainIntentService.EXTRA_DATA, data); + + // Create a new Messenger for the communication back + Messenger messenger = new Messenger(saveHandler); + intent.putExtra(KeychainIntentService.EXTRA_MESSENGER, messenger); + + // show progress dialog + saveHandler.showProgressDialog(getActivity()); + + // start service with intent + getActivity().startService(intent); + + } + + + @Override + public void onActivityResult(int requestCode, int resultCode, Intent data) { + switch (requestCode) { + // For saving a file + case REQUEST_CODE_OUTPUT: + if (data == null) { + return; + } + Uri uri = data.getData(); + saveFile(uri); + break; + case REQUEST_CODE_PASSPHRASE: + if (resultCode == Activity.RESULT_OK && data != null) { + String passphrase = + data.getStringExtra(PassphraseDialogActivity.MESSAGE_DATA_PASSPHRASE); + certifyLinkedIdentity(passphrase); + } + break; + } + super.onActivityResult(requestCode, resultCode, data); + } + +} diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java new file mode 100644 index 000000000..7c5f1f032 --- /dev/null +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java @@ -0,0 +1,132 @@ +/* + * Copyright (C) 2014 Dominik Schürmann + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package org.sufficientlysecure.keychain.ui.linked; + +import android.os.Bundle; +import android.support.v4.app.Fragment; +import android.text.Editable; +import android.text.TextWatcher; +import android.util.Patterns; +import android.view.LayoutInflater; +import android.view.View; +import android.view.View.OnClickListener; +import android.view.ViewGroup; +import android.widget.EditText; + +import org.sufficientlysecure.keychain.R; +import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; +import org.sufficientlysecure.keychain.pgp.linked.resources.GenericHttpsResource; + +public class LinkedIdCreateHttpsStep1Fragment extends Fragment { + + LinkedIdWizard mLinkedIdWizard; + + EditText mEditUri; + + /** + * Creates new instance of this fragment + */ + public static LinkedIdCreateHttpsStep1Fragment newInstance() { + LinkedIdCreateHttpsStep1Fragment frag = new LinkedIdCreateHttpsStep1Fragment(); + + Bundle args = new Bundle(); + frag.setArguments(args); + + return frag; + } + + @Override + public void onActivityCreated(Bundle savedInstanceState) { + super.onActivityCreated(savedInstanceState); + + mLinkedIdWizard = (LinkedIdWizard) getActivity(); + + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + final View view = inflater.inflate(R.layout.linked_create_https_fragment_step1, container, false); + + view.findViewById(R.id.next_button).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + + String uri = "https://" + mEditUri.getText(); + + if (!checkUri(uri)) { + return; + } + + String proofNonce = LinkedIdentity.generateNonce(); + String proofText = GenericHttpsResource.generateText(getActivity(), + mLinkedIdWizard.mFingerprint, proofNonce); + + LinkedIdCreateHttpsStep2Fragment frag = + LinkedIdCreateHttpsStep2Fragment.newInstance(uri, proofNonce, proofText); + + mLinkedIdWizard.loadFragment(null, frag, LinkedIdWizard.FRAG_ACTION_TO_RIGHT); + + } + }); + + view.findViewById(R.id.back_button).setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + mLinkedIdWizard.loadFragment(null, null, LinkedIdWizard.FRAG_ACTION_TO_LEFT); + } + }); + + mEditUri = (EditText) view.findViewById(R.id.linked_create_https_uri); + + mEditUri.addTextChangedListener(new TextWatcher() { + @Override + public void beforeTextChanged(CharSequence charSequence, int i, int i2, int i3) { + } + + @Override + public void onTextChanged(CharSequence charSequence, int i, int i2, int i3) { + } + + @Override + public void afterTextChanged(Editable editable) { + String uri = "https://" + editable; + if (uri.length() > 0) { + if (checkUri(uri)) { + mEditUri.setCompoundDrawablesWithIntrinsicBounds(0, 0, + R.drawable.uid_mail_ok, 0); + } else { + mEditUri.setCompoundDrawablesWithIntrinsicBounds(0, 0, + R.drawable.uid_mail_bad, 0); + } + } else { + // remove drawable if email is empty + mEditUri.setCompoundDrawablesWithIntrinsicBounds(0, 0, 0, 0); + } + } + }); + + mEditUri.setText("mugenguild.com/pgpkey.txt"); + + return view; + } + + private static boolean checkUri(String uri) { + return Patterns.WEB_URL.matcher(uri).matches(); + } + +} diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java new file mode 100644 index 000000000..0d78bad27 --- /dev/null +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java @@ -0,0 +1,366 @@ +/* + * Copyright (C) 2014 Dominik Schürmann + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package org.sufficientlysecure.keychain.ui.linked; + +import android.app.Activity; +import android.app.ProgressDialog; +import android.content.Intent; +import android.graphics.PorterDuff; +import android.net.Uri; +import android.os.AsyncTask; +import android.os.Build; +import android.os.Bundle; +import android.os.Environment; +import android.os.Message; +import android.os.Messenger; +import android.support.v4.app.Fragment; +import android.view.LayoutInflater; +import android.view.View; +import android.view.View.OnClickListener; +import android.view.ViewGroup; +import android.widget.EditText; +import android.widget.ImageView; +import android.widget.TextView; + +import org.sufficientlysecure.keychain.Constants; +import org.sufficientlysecure.keychain.R; +import org.sufficientlysecure.keychain.operations.results.LinkedVerifyResult; +import org.sufficientlysecure.keychain.operations.results.OperationResult; +import org.sufficientlysecure.keychain.pgp.WrappedUserAttribute; +import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; +import org.sufficientlysecure.keychain.pgp.linked.resources.GenericHttpsResource; +import org.sufficientlysecure.keychain.service.KeychainIntentService; +import org.sufficientlysecure.keychain.service.KeychainIntentServiceHandler; +import org.sufficientlysecure.keychain.service.SaveKeyringParcel; +import org.sufficientlysecure.keychain.ui.PassphraseDialogActivity; +import org.sufficientlysecure.keychain.ui.util.Notify; +import org.sufficientlysecure.keychain.ui.util.Notify.Style; +import org.sufficientlysecure.keychain.util.FileHelper; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.PrintWriter; +import java.net.URI; +import java.net.URISyntaxException; + +public class LinkedIdCreateHttpsStep2Fragment extends Fragment { + + private static final int REQUEST_CODE_OUTPUT = 0x00007007; + private static final int REQUEST_CODE_PASSPHRASE = 0x00007008; + + public static final String URI = "uri", NONCE = "nonce", TEXT = "text"; + + LinkedIdWizard mLinkedIdWizard; + + EditText mEditUri; + ImageView mVerifyImage; + View mVerifyProgress; + TextView mVerifyStatus; + + String mResourceUri; + String mResourceNonce, mResourceString; + + // This is a resource, set AFTER it has been verified + GenericHttpsResource mVerifiedResource = null; + + /** + * Creates new instance of this fragment + */ + public static LinkedIdCreateHttpsStep2Fragment newInstance + (String uri, String proofNonce, String proofText) { + + LinkedIdCreateHttpsStep2Fragment frag = new LinkedIdCreateHttpsStep2Fragment(); + + Bundle args = new Bundle(); + args.putString(URI, uri); + args.putString(NONCE, proofNonce); + args.putString(TEXT, proofText); + frag.setArguments(args); + + return frag; + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + final View view = inflater.inflate(R.layout.linked_create_https_fragment_step2, container, false); + + mResourceUri = getArguments().getString(URI); + mResourceNonce = getArguments().getString(NONCE); + mResourceString = getArguments().getString(TEXT); + + view.findViewById(R.id.next_button).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + startCertify(); + } + }); + + view.findViewById(R.id.back_button).setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + mLinkedIdWizard.loadFragment(null, null, LinkedIdWizard.FRAG_ACTION_TO_LEFT); + } + }); + + mVerifyImage = (ImageView) view.findViewById(R.id.verify_image); + mVerifyProgress = view.findViewById(R.id.verify_progress); + mVerifyStatus = (TextView) view.findViewById(R.id.verify_status); + + view.findViewById(R.id.button_send).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + proofSend(); + } + }); + + view.findViewById(R.id.button_save).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + proofSave(); + } + }); + + view.findViewById(R.id.button_verify).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + proofVerify(); + } + }); + + mEditUri = (EditText) view.findViewById(R.id.linked_create_https_uri); + mEditUri.setText(mResourceUri); + + setVerifyProgress(false, null); + mVerifyStatus.setText(R.string.linked_verify_pending); + + return view; + } + + @Override + public void onActivityCreated(Bundle savedInstanceState) { + super.onActivityCreated(savedInstanceState); + + mLinkedIdWizard = (LinkedIdWizard) getActivity(); + } + + public void setVerifyProgress(boolean on, Boolean success) { + mVerifyProgress.setVisibility(on ? View.VISIBLE : View.GONE); + mVerifyImage.setVisibility(on ? View.GONE : View.VISIBLE); + if (success == null) { + mVerifyStatus.setText(R.string.linked_verifying); + mVerifyImage.setImageResource(R.drawable.status_signature_unverified_cutout); + mVerifyImage.setColorFilter(getResources().getColor(R.color.tertiary_text_light), + PorterDuff.Mode.SRC_IN); + } else if (success) { + mVerifyStatus.setText(R.string.linked_verify_success); + mVerifyImage.setImageResource(R.drawable.status_signature_verified_cutout); + mVerifyImage.setColorFilter(getResources().getColor(R.color.android_green_dark), + PorterDuff.Mode.SRC_IN); + } else { + mVerifyStatus.setText(R.string.linked_verify_error); + mVerifyImage.setImageResource(R.drawable.status_signature_unknown_cutout); + mVerifyImage.setColorFilter(getResources().getColor(R.color.android_red_dark), + PorterDuff.Mode.SRC_IN); + } + } + + private void proofSend () { + Intent sendIntent = new Intent(); + sendIntent.setAction(Intent.ACTION_SEND); + sendIntent.putExtra(Intent.EXTRA_TEXT, mResourceString); + sendIntent.setType("text/plain"); + startActivity(sendIntent); + } + + private void proofSave () { + String state = Environment.getExternalStorageState(); + if (!Environment.MEDIA_MOUNTED.equals(state)) { + Notify.showNotify(getActivity(), "External storage not available!", Style.ERROR); + return; + } + + String targetName = "pgpkey.txt"; + + if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) { + File targetFile = new File(Constants.Path.APP_DIR, targetName); + FileHelper.saveFile(this, getString(R.string.title_decrypt_to_file), + getString(R.string.specify_file_to_decrypt_to), targetFile, REQUEST_CODE_OUTPUT); + } else { + FileHelper.saveDocument(this, "text/plain", targetName, REQUEST_CODE_OUTPUT); + } + } + + private void saveFile(Uri uri) { + try { + PrintWriter out = + new PrintWriter(getActivity().getContentResolver().openOutputStream(uri)); + out.print(mResourceString); + if (out.checkError()) { + Notify.showNotify(getActivity(), "Error writing file!", Style.ERROR); + } + } catch (FileNotFoundException e) { + Notify.showNotify(getActivity(), "File could not be opened for writing!", Style.ERROR); + e.printStackTrace(); + } + } + + public void proofVerify() { + setVerifyProgress(true, null); + + try { + final GenericHttpsResource resource = GenericHttpsResource.createNew(new URI(mResourceUri)); + + new AsyncTask() { + + @Override + protected LinkedVerifyResult doInBackground(Void... params) { + return resource.verify(mLinkedIdWizard.mFingerprint, mResourceNonce); + } + + @Override + protected void onPostExecute(LinkedVerifyResult result) { + super.onPostExecute(result); + if (result.success()) { + setVerifyProgress(false, true); + mVerifiedResource = resource; + } else { + setVerifyProgress(false, false); + // on error, show error message + result.createNotify(getActivity()).show(); + } + } + }.execute(); + } catch (URISyntaxException e) { + e.printStackTrace(); + } + + } + + public void startCertify() { + + if (mVerifiedResource == null) { + Notify.showNotify(getActivity(), R.string.linked_need_verify, Notify.Style.ERROR); + return; + } + + Intent intent = new Intent(getActivity(), PassphraseDialogActivity.class); + intent.putExtra(PassphraseDialogActivity.EXTRA_SUBKEY_ID, mLinkedIdWizard.mMasterKeyId); + startActivityForResult(intent, REQUEST_CODE_PASSPHRASE); + + } + + public void certifyLinkedIdentity (String passphrase) { + KeychainIntentServiceHandler saveHandler = new KeychainIntentServiceHandler( + getActivity(), + getString(R.string.progress_saving), + ProgressDialog.STYLE_HORIZONTAL, + true) { + public void handleMessage(Message message) { + // handle messages by standard KeychainIntentServiceHandler first + super.handleMessage(message); + + if (message.arg1 == KeychainIntentServiceHandler.MESSAGE_OKAY) { + + // get returned data bundle + Bundle returnData = message.getData(); + if (returnData == null) { + return; + } + final OperationResult result = + returnData.getParcelable(OperationResult.EXTRA_RESULT); + if (result == null) { + return; + } + + // if bad -> display here! + if (!result.success()) { + result.createNotify(getActivity()).show(); + return; + } + + result.createNotify(getActivity()).show(); + + // if good -> finish, return result to showkey and display there! + // Intent intent = new Intent(); + // intent.putExtra(OperationResult.EXTRA_RESULT, result); + // getActivity().setResult(EditKeyActivity.RESULT_OK, intent); + + // AffirmationCreateHttpsStep3Fragment frag = + // AffirmationCreateHttpsStep3Fragment.newInstance( + // mResourceUri, mResourceNonce, mResourceString); + + // mAffirmationWizard.loadFragment(null, frag, AffirmationWizard.FRAG_ACTION_TO_RIGHT); + + } + } + }; + + SaveKeyringParcel skp = + new SaveKeyringParcel(mLinkedIdWizard.mMasterKeyId, mLinkedIdWizard.mFingerprint); + + WrappedUserAttribute ua = + LinkedIdentity.fromResource(mVerifiedResource, mResourceNonce).toUserAttribute(); + + skp.mAddUserAttribute.add(ua); + + // Send all information needed to service to import key in other thread + Intent intent = new Intent(getActivity(), KeychainIntentService.class); + intent.setAction(KeychainIntentService.ACTION_EDIT_KEYRING); + + // fill values for this action + Bundle data = new Bundle(); + data.putString(KeychainIntentService.EDIT_KEYRING_PASSPHRASE, passphrase); + data.putParcelable(KeychainIntentService.EDIT_KEYRING_PARCEL, skp); + intent.putExtra(KeychainIntentService.EXTRA_DATA, data); + + // Create a new Messenger for the communication back + Messenger messenger = new Messenger(saveHandler); + intent.putExtra(KeychainIntentService.EXTRA_MESSENGER, messenger); + + // show progress dialog + saveHandler.showProgressDialog(getActivity()); + + // start service with intent + getActivity().startService(intent); + + } + + + @Override + public void onActivityResult(int requestCode, int resultCode, Intent data) { + switch (requestCode) { + // For saving a file + case REQUEST_CODE_OUTPUT: + if (data == null) { + return; + } + Uri uri = data.getData(); + saveFile(uri); + break; + case REQUEST_CODE_PASSPHRASE: + if (resultCode == Activity.RESULT_OK && data != null) { + String passphrase = + data.getStringExtra(PassphraseDialogActivity.MESSAGE_DATA_PASSPHRASE); + certifyLinkedIdentity(passphrase); + } + break; + } + super.onActivityResult(requestCode, resultCode, data); + } + +} diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java new file mode 100644 index 000000000..25a4f6463 --- /dev/null +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java @@ -0,0 +1,134 @@ +/* + * Copyright (C) 2014 Dominik Schürmann + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package org.sufficientlysecure.keychain.ui.linked; + +import android.os.AsyncTask; +import android.os.Bundle; +import android.support.v4.app.Fragment; +import android.view.LayoutInflater; +import android.view.View; +import android.view.View.OnClickListener; +import android.view.ViewGroup; +import android.widget.EditText; + +import org.sufficientlysecure.keychain.R; +import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; +import org.sufficientlysecure.keychain.pgp.linked.resources.TwitterResource; +import org.sufficientlysecure.keychain.ui.util.Notify; + +import java.io.IOException; +import java.net.HttpURLConnection; +import java.net.URL; + +public class LinkedIdCreateTwitterStep1Fragment extends Fragment { + + LinkedIdWizard mLinkedIdWizard; + + EditText mEditHandle; + + /** + * Creates new instance of this fragment + */ + public static LinkedIdCreateTwitterStep1Fragment newInstance() { + LinkedIdCreateTwitterStep1Fragment frag = new LinkedIdCreateTwitterStep1Fragment(); + + Bundle args = new Bundle(); + frag.setArguments(args); + + return frag; + } + + @Override + public void onActivityCreated(Bundle savedInstanceState) { + super.onActivityCreated(savedInstanceState); + + mLinkedIdWizard = (LinkedIdWizard) getActivity(); + + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + final View view = inflater.inflate(R.layout.linked_create_twitter_fragment_step1, container, false); + + view.findViewById(R.id.next_button).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + + final String handle = mEditHandle.getText().toString(); + + new AsyncTask() { + + @Override + protected Boolean doInBackground(Void... params) { + return true; // checkHandle(handle); + } + + @Override + protected void onPostExecute(Boolean result) { + super.onPostExecute(result); + + if (result == null) { + Notify.showNotify(getActivity(), "Connection error while checking username!", Notify.Style.ERROR); + return; + } + + if (!result) { + Notify.showNotify(getActivity(), "This handle does not exist on Twitter!", Notify.Style.ERROR); + return; + } + + String proofNonce = LinkedIdentity.generateNonce(); + String proofText = TwitterResource.generateText(getActivity(), + mLinkedIdWizard.mFingerprint, proofNonce); + + LinkedIdCreateTwitterStep2Fragment frag = + LinkedIdCreateTwitterStep2Fragment.newInstance(handle, proofNonce, proofText); + + mLinkedIdWizard.loadFragment(null, frag, LinkedIdWizard.FRAG_ACTION_TO_RIGHT); + } + }.execute(); + + } + }); + + view.findViewById(R.id.back_button).setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + mLinkedIdWizard.loadFragment(null, null, LinkedIdWizard.FRAG_ACTION_TO_LEFT); + } + }); + + mEditHandle = (EditText) view.findViewById(R.id.linked_create_twitter_handle); + mEditHandle.setText("Valodim"); + + return view; + } + + private static Boolean checkHandle(String handle) { + try { + HttpURLConnection nection = + (HttpURLConnection) new URL("https://twitter.com/" + handle).openConnection(); + nection.setRequestMethod("HEAD"); + return nection.getResponseCode() == 200; + } catch (IOException e) { + e.printStackTrace(); + return null; + } + } + +} diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java new file mode 100644 index 000000000..c02a76669 --- /dev/null +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java @@ -0,0 +1,149 @@ +/* + * Copyright (C) 2014 Dominik Schürmann + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package org.sufficientlysecure.keychain.ui.linked; + +import android.os.Bundle; +import android.support.v4.app.Fragment; +import android.text.Editable; +import android.text.InputFilter; +import android.text.TextWatcher; +import android.view.LayoutInflater; +import android.view.View; +import android.view.View.OnClickListener; +import android.view.ViewGroup; +import android.widget.EditText; +import android.widget.ImageView; +import android.widget.TextView; + +import org.sufficientlysecure.keychain.R; + +public class LinkedIdCreateTwitterStep2Fragment extends Fragment { + + private static final int REQUEST_CODE_OUTPUT = 0x00007007; + + public static final String HANDLE = "uri", NONCE = "nonce", TEXT = "text"; + + LinkedIdWizard mLinkedIdWizard; + + EditText mEditTweetCustom, mEditTweetPreview; + ImageView mVerifyImage; + View mVerifyProgress; + TextView mVerifyStatus, mEditTweetTextLen; + + String mResourceHandle; + String mResourceNonce, mResourceString; + + /** + * Creates new instance of this fragment + */ + public static LinkedIdCreateTwitterStep2Fragment newInstance + (String handle, String proofNonce, String proofText) { + + LinkedIdCreateTwitterStep2Fragment frag = new LinkedIdCreateTwitterStep2Fragment(); + + Bundle args = new Bundle(); + args.putString(HANDLE, handle); + args.putString(NONCE, proofNonce); + args.putString(TEXT, proofText); + frag.setArguments(args); + + return frag; + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + final View view = inflater.inflate(R.layout.linked_create_twitter_fragment_step2, container, false); + + mResourceHandle = getArguments().getString(HANDLE); + mResourceNonce = getArguments().getString(NONCE); + mResourceString = getArguments().getString(TEXT); + + view.findViewById(R.id.next_button).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + + LinkedIdCreateTwitterStep3Fragment frag = + LinkedIdCreateTwitterStep3Fragment.newInstance(mResourceHandle, + mResourceNonce, mResourceString, + mEditTweetCustom.getText().toString()); + + mLinkedIdWizard.loadFragment(null, frag, LinkedIdWizard.FRAG_ACTION_TO_RIGHT); + } + }); + + view.findViewById(R.id.back_button).setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + mLinkedIdWizard.loadFragment(null, null, LinkedIdWizard.FRAG_ACTION_TO_LEFT); + } + }); + + mVerifyImage = (ImageView) view.findViewById(R.id.verify_image); + mVerifyProgress = view.findViewById(R.id.verify_progress); + mVerifyStatus = (TextView) view.findViewById(R.id.verify_status); + + mEditTweetPreview = (EditText) view.findViewById(R.id.linked_create_twitter_preview); + mEditTweetPreview.setText(mResourceString); + + mEditTweetCustom = (EditText) view.findViewById(R.id.linked_create_twitter_custom); + mEditTweetCustom.setFilters(new InputFilter[] { + new InputFilter.LengthFilter(139 - mResourceString.length()) + }); + + mEditTweetTextLen = (TextView) view.findViewById(R.id.linked_create_twitter_textlen); + mEditTweetTextLen.setText(mResourceString.length() + "/140"); + + mEditTweetCustom.addTextChangedListener(new TextWatcher() { + @Override + public void beforeTextChanged(CharSequence charSequence, int i, int i2, int i3) { + } + + @Override + public void onTextChanged(CharSequence charSequence, int i, int i2, int i3) { + } + + @Override + public void afterTextChanged(Editable editable) { + if (editable != null && editable.length() > 0) { + String str = editable + " " + mResourceString; + mEditTweetPreview.setText(str); + + mEditTweetTextLen.setText(str.length() + "/140"); + mEditTweetTextLen.setTextColor(getResources().getColor(str.length() == 140 + ? R.color.android_red_dark + : R.color.primary_dark_material_light)); + + + } else { + mEditTweetPreview.setText(mResourceString); + mEditTweetTextLen.setText(mResourceString.length() + "/140"); + } + } + }); + + return view; + } + + @Override + public void onActivityCreated(Bundle savedInstanceState) { + super.onActivityCreated(savedInstanceState); + + mLinkedIdWizard = (LinkedIdWizard) getActivity(); + } + +} diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java new file mode 100644 index 000000000..23e50d9dc --- /dev/null +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java @@ -0,0 +1,235 @@ +/* + * Copyright (C) 2014 Dominik Schürmann + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package org.sufficientlysecure.keychain.ui.linked; + +import android.content.Intent; +import android.content.pm.PackageManager; +import android.content.pm.ResolveInfo; +import android.graphics.PorterDuff; +import android.os.Bundle; +import android.support.v4.app.Fragment; +import android.view.LayoutInflater; +import android.view.View; +import android.view.View.OnClickListener; +import android.view.ViewGroup; +import android.widget.EditText; +import android.widget.ImageView; +import android.widget.TextView; + +import org.sufficientlysecure.keychain.R; +import org.sufficientlysecure.keychain.ui.util.Notify; + +import java.util.List; + +public class LinkedIdCreateTwitterStep3Fragment extends Fragment { + + public static final String HANDLE = "uri", NONCE = "nonce", TEXT = "text", CUSTOM = "custom"; + + LinkedIdWizard mLinkedIdWizard; + + EditText mEditTweetPreview; + ImageView mVerifyImage; + View mVerifyProgress; + TextView mVerifyStatus; + + String mResourceHandle, mCustom, mFullString; + String mResourceNonce, mResourceString; + + /** + * Creates new instance of this fragment + */ + public static LinkedIdCreateTwitterStep3Fragment newInstance + (String handle, String proofNonce, String proofText, String customText) { + + LinkedIdCreateTwitterStep3Fragment frag = new LinkedIdCreateTwitterStep3Fragment(); + + Bundle args = new Bundle(); + args.putString(HANDLE, handle); + args.putString(NONCE, proofNonce); + args.putString(TEXT, proofText); + args.putString(CUSTOM, customText); + frag.setArguments(args); + + return frag; + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + final View view = inflater.inflate(R.layout.linked_create_twitter_fragment_step3, container, false); + + mResourceHandle = getArguments().getString(HANDLE); + mResourceNonce = getArguments().getString(NONCE); + mResourceString = getArguments().getString(TEXT); + mCustom = getArguments().getString(CUSTOM); + + mFullString = mCustom.isEmpty() ? mResourceString : (mCustom + " " + mResourceString); + + mVerifyImage = (ImageView) view.findViewById(R.id.verify_image); + mVerifyProgress = view.findViewById(R.id.verify_progress); + mVerifyStatus = (TextView) view.findViewById(R.id.verify_status); + + mEditTweetPreview = (EditText) view.findViewById(R.id.linked_create_twitter_preview); + mEditTweetPreview.setText(mFullString); + + view.findViewById(R.id.back_button).setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + mLinkedIdWizard.loadFragment(null, null, LinkedIdWizard.FRAG_ACTION_TO_LEFT); + } + }); + + view.findViewById(R.id.button_send).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + proofSend(); + } + }); + + view.findViewById(R.id.button_share).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + proofShare(); + } + }); + + view.findViewById(R.id.button_verify).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + proofVerify(); + } + }); + + setVerifyProgress(false, null); + mVerifyStatus.setText(R.string.linked_verify_pending); + + + view.findViewById(R.id.next_button).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + + // AffirmationCreateHttpsStep2Fragment frag = + // AffirmationCreateHttpsStep2Fragment.newInstance(); + + // mAffirmationWizard.loadFragment(null, frag, AffirmationWizard.FRAG_ACTION_TO_RIGHT); + } + }); + + return view; + } + + @Override + public void onActivityCreated(Bundle savedInstanceState) { + super.onActivityCreated(savedInstanceState); + + mLinkedIdWizard = (LinkedIdWizard) getActivity(); + } + + public void setVerifyProgress(boolean on, Boolean success) { + mVerifyProgress.setVisibility(on ? View.VISIBLE : View.GONE); + mVerifyImage.setVisibility(on ? View.GONE : View.VISIBLE); + if (success == null) { + mVerifyStatus.setText(R.string.linked_verifying); + mVerifyImage.setImageResource(R.drawable.status_signature_unverified_cutout); + mVerifyImage.setColorFilter(getResources().getColor(R.color.tertiary_text_light), + PorterDuff.Mode.SRC_IN); + } else if (success) { + mVerifyStatus.setText(R.string.linked_verify_success); + mVerifyImage.setImageResource(R.drawable.status_signature_verified_cutout); + mVerifyImage.setColorFilter(getResources().getColor(R.color.android_green_dark), + PorterDuff.Mode.SRC_IN); + } else { + mVerifyStatus.setText(R.string.linked_verify_error); + mVerifyImage.setImageResource(R.drawable.status_signature_unknown_cutout); + mVerifyImage.setColorFilter(getResources().getColor(R.color.android_red_dark), + PorterDuff.Mode.SRC_IN); + } + } + + public void proofVerify() { + setVerifyProgress(true, null); + + /* + try { + final TwitterResource resource = TwitterResource.createNew(new URI(mResourceHandle)); + + new AsyncTask() { + + @Override + protected LinkedVerifyResult doInBackground(Void... params) { + return resource.verify(mAffirmationWizard.mFingerprint, mResourceNonce); + } + + @Override + protected void onPostExecute(LinkedVerifyResult result) { + super.onPostExecute(result); + if (result.success()) { + setVerifyProgress(false, true); + } else { + setVerifyProgress(false, false); + // on error, show error message + result.createNotify(getActivity()).show(); + } + } + }.execute(); + } catch (URISyntaxException e) { + e.printStackTrace(); + } + */ + + } + + private void proofShare() { + Intent sendIntent = new Intent(); + sendIntent.setAction(Intent.ACTION_SEND); + sendIntent.putExtra(Intent.EXTRA_TEXT, mFullString); + sendIntent.setType("text/plain"); + startActivity(sendIntent); + } + + private void proofSend() { + + Intent tweetIntent = new Intent(Intent.ACTION_SEND); + tweetIntent.putExtra(Intent.EXTRA_TEXT, mFullString); + tweetIntent.setType("text/plain"); + + PackageManager packManager = getActivity().getPackageManager(); + List resolvedInfoList = packManager.queryIntentActivities(tweetIntent, + PackageManager.MATCH_DEFAULT_ONLY); + + boolean resolved = false; + for(ResolveInfo resolveInfo : resolvedInfoList){ + if(resolveInfo.activityInfo.packageName.startsWith("com.twitter.android")) { + tweetIntent.setClassName( + resolveInfo.activityInfo.packageName, + resolveInfo.activityInfo.name ); + resolved = true; + break; + } + } + + if (resolved) { + startActivity(tweetIntent); + } else { + Notify.showNotify(getActivity(), + "Twitter app is not installed, please use the send intent!", + Notify.Style.ERROR); + } + + } + +} diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdSelectFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdSelectFragment.java new file mode 100644 index 000000000..abe7dbaf1 --- /dev/null +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdSelectFragment.java @@ -0,0 +1,91 @@ +/* + * Copyright (C) 2014 Dominik Schürmann + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package org.sufficientlysecure.keychain.ui.linked; + +import android.os.Bundle; +import android.support.v4.app.Fragment; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; + +import org.sufficientlysecure.keychain.R; + +public class LinkedIdSelectFragment extends Fragment { + + LinkedIdWizard mLinkedIdWizard; + + /** + * Creates new instance of this fragment + */ + public static LinkedIdSelectFragment newInstance() { + LinkedIdSelectFragment frag = new LinkedIdSelectFragment(); + + Bundle args = new Bundle(); + frag.setArguments(args); + + return frag; + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + View view = inflater.inflate(R.layout.linked_select_fragment, container, false); + + view.findViewById(R.id.linked_create_https_button) + .setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + LinkedIdCreateHttpsStep1Fragment frag = + LinkedIdCreateHttpsStep1Fragment.newInstance(); + + mLinkedIdWizard.loadFragment(null, frag, LinkedIdWizard.FRAG_ACTION_TO_RIGHT); + } + }); + + view.findViewById(R.id.linked_create_dns_button) + .setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + LinkedIdCreateDnsStep1Fragment frag = + LinkedIdCreateDnsStep1Fragment.newInstance(); + + mLinkedIdWizard.loadFragment(null, frag, LinkedIdWizard.FRAG_ACTION_TO_RIGHT); + } + }); + + view.findViewById(R.id.linked_create_twitter_button) + .setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + LinkedIdCreateTwitterStep1Fragment frag = + LinkedIdCreateTwitterStep1Fragment.newInstance(); + + mLinkedIdWizard.loadFragment(null, frag, LinkedIdWizard.FRAG_ACTION_TO_RIGHT); + } + }); + + return view; + } + + @Override + public void onActivityCreated(Bundle savedInstanceState) { + super.onActivityCreated(savedInstanceState); + + mLinkedIdWizard = (LinkedIdWizard) getActivity(); + } + +} diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdWizard.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdWizard.java new file mode 100644 index 000000000..b8f3329c1 --- /dev/null +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdWizard.java @@ -0,0 +1,98 @@ +/* + * Copyright (C) 2014 Dominik Schürmann + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package org.sufficientlysecure.keychain.ui.linked; + +import android.net.Uri; +import android.os.Bundle; +import android.support.v4.app.Fragment; +import android.support.v4.app.FragmentTransaction; +import android.support.v7.app.ActionBarActivity; + +import org.sufficientlysecure.keychain.Constants; +import org.sufficientlysecure.keychain.R; +import org.sufficientlysecure.keychain.pgp.exception.PgpKeyNotFoundException; +import org.sufficientlysecure.keychain.provider.CachedPublicKeyRing; +import org.sufficientlysecure.keychain.provider.ProviderHelper; +import org.sufficientlysecure.keychain.util.Log; + +public class LinkedIdWizard extends ActionBarActivity { + + public static final int FRAG_ACTION_START = 0; + public static final int FRAG_ACTION_TO_RIGHT = 1; + public static final int FRAG_ACTION_TO_LEFT = 2; + + long mMasterKeyId; + byte[] mFingerprint; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + + setContentView(R.layout.create_key_activity); + + try { + Uri uri = getIntent().getData(); + CachedPublicKeyRing ring = new ProviderHelper(this).getCachedPublicKeyRing(uri); + mMasterKeyId = ring.extractOrGetMasterKeyId(); + mFingerprint = ring.getFingerprint(); + } catch (PgpKeyNotFoundException e) { + Log.e(Constants.TAG, "Invalid uri given, key does not exist!"); + finish(); + return; + } + + // pass extras into fragment + LinkedIdSelectFragment frag = LinkedIdSelectFragment.newInstance(); + loadFragment(null, frag, FRAG_ACTION_START); + } + + public void loadFragment(Bundle savedInstanceState, Fragment fragment, int action) { + // However, if we're being restored from a previous state, + // then we don't need to do anything and should return or else + // we could end up with overlapping fragments. + if (savedInstanceState != null) { + return; + } + + // Add the fragment to the 'fragment_container' FrameLayout + // NOTE: We use commitAllowingStateLoss() to prevent weird crashes! + FragmentTransaction transaction = getSupportFragmentManager().beginTransaction(); + + switch (action) { + case FRAG_ACTION_START: + transaction.setCustomAnimations(0, 0); + transaction.replace(R.id.create_key_fragment_container, fragment) + .commitAllowingStateLoss(); + break; + case FRAG_ACTION_TO_LEFT: + getSupportFragmentManager().popBackStackImmediate(); + break; + case FRAG_ACTION_TO_RIGHT: + transaction.setCustomAnimations(R.anim.frag_slide_in_from_right, R.anim.frag_slide_out_to_left, + R.anim.frag_slide_in_from_left, R.anim.frag_slide_out_to_right); + transaction.addToBackStack(null); + transaction.replace(R.id.create_key_fragment_container, fragment) + .commitAllowingStateLoss(); + break; + + } + // do it immediately! + getSupportFragmentManager().executePendingTransactions(); + } + +} -- cgit v1.2.3 From b6a1463161779b820a8b03a9d17c8a35dccea338 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Fri, 16 Jan 2015 13:57:18 +0100 Subject: dns resource is parametrized by fqdn, class and type --- .../keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java index ba57ace4b..973067246 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java @@ -121,7 +121,7 @@ public class LinkedIdCreateDnsStep1Fragment extends Fragment { } }); - mEditDns.setText("mugenguild.com"); + mEditDns.setText("test.mugenguild.com"); return view; } -- cgit v1.2.3 From 6c153b15430c00b5213062be4bb5830d52f2589a Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Fri, 16 Jan 2015 15:59:26 +0100 Subject: linked id ui work dns/twitter --- .../ui/linked/LinkedIdCreateDnsStep2Fragment.java | 6 +++--- .../ui/linked/LinkedIdCreateTwitterStep2Fragment.java | 15 +++++++++------ 2 files changed, 12 insertions(+), 9 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java index ff8d03dd4..1106a4a48 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java @@ -65,7 +65,7 @@ public class LinkedIdCreateDnsStep2Fragment extends Fragment { LinkedIdWizard mLinkedIdWizard; - EditText mEditUri; + TextView mTextView; ImageView mVerifyImage; View mVerifyProgress; TextView mVerifyStatus; @@ -140,8 +140,8 @@ public class LinkedIdCreateDnsStep2Fragment extends Fragment { } }); - mEditUri = (EditText) view.findViewById(R.id.linked_create_dns_text); - mEditUri.setText(mResourceString); + mTextView = (TextView) view.findViewById(R.id.linked_create_dns_text); + mTextView.setText(mResourceString); setVerifyProgress(false, null); mVerifyStatus.setText(R.string.linked_verify_pending); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java index c02a76669..ab56e7a5d 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java @@ -31,11 +31,10 @@ import android.widget.ImageView; import android.widget.TextView; import org.sufficientlysecure.keychain.R; +import org.sufficientlysecure.keychain.pgp.linked.resources.TwitterResource; public class LinkedIdCreateTwitterStep2Fragment extends Fragment { - private static final int REQUEST_CODE_OUTPUT = 0x00007007; - public static final String HANDLE = "uri", NONCE = "nonce", TEXT = "text"; LinkedIdWizard mLinkedIdWizard; @@ -47,6 +46,7 @@ public class LinkedIdCreateTwitterStep2Fragment extends Fragment { String mResourceHandle; String mResourceNonce, mResourceString; + String mCookiePreview; /** * Creates new instance of this fragment @@ -69,6 +69,8 @@ public class LinkedIdCreateTwitterStep2Fragment extends Fragment { public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { final View view = inflater.inflate(R.layout.linked_create_twitter_fragment_step2, container, false); + mCookiePreview = TwitterResource.generatePreview(); + mResourceHandle = getArguments().getString(HANDLE); mResourceNonce = getArguments().getString(NONCE); mResourceString = getArguments().getString(TEXT); @@ -98,7 +100,7 @@ public class LinkedIdCreateTwitterStep2Fragment extends Fragment { mVerifyStatus = (TextView) view.findViewById(R.id.verify_status); mEditTweetPreview = (EditText) view.findViewById(R.id.linked_create_twitter_preview); - mEditTweetPreview.setText(mResourceString); + mEditTweetPreview.setText(mCookiePreview); mEditTweetCustom = (EditText) view.findViewById(R.id.linked_create_twitter_custom); mEditTweetCustom.setFilters(new InputFilter[] { @@ -120,17 +122,18 @@ public class LinkedIdCreateTwitterStep2Fragment extends Fragment { @Override public void afterTextChanged(Editable editable) { if (editable != null && editable.length() > 0) { - String str = editable + " " + mResourceString; + String str = editable + " " + mCookiePreview; mEditTweetPreview.setText(str); - mEditTweetTextLen.setText(str.length() + "/140"); + mEditTweetTextLen.setText( + (editable.length() + mResourceString.length() + 1) + "/140"); mEditTweetTextLen.setTextColor(getResources().getColor(str.length() == 140 ? R.color.android_red_dark : R.color.primary_dark_material_light)); } else { - mEditTweetPreview.setText(mResourceString); + mEditTweetPreview.setText(mCookiePreview); mEditTweetTextLen.setText(mResourceString.length() + "/140"); } } -- cgit v1.2.3 From 5e53a5417c11f54f437d9f220d3e2e8579b8bf1b Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Mon, 2 Mar 2015 14:45:44 +0100 Subject: some fixes for compiling (still not working!) --- .../keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java | 6 +++--- .../keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java | 6 +++--- .../keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java | 6 +++--- 3 files changed, 9 insertions(+), 9 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java index 1106a4a48..3c413556d 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java @@ -161,17 +161,17 @@ public class LinkedIdCreateDnsStep2Fragment extends Fragment { mVerifyImage.setVisibility(on ? View.GONE : View.VISIBLE); if (success == null) { mVerifyStatus.setText(R.string.linked_verifying); - mVerifyImage.setImageResource(R.drawable.status_signature_unverified_cutout); + mVerifyImage.setImageResource(R.drawable.status_signature_unverified_cutout_24px); mVerifyImage.setColorFilter(getResources().getColor(R.color.tertiary_text_light), PorterDuff.Mode.SRC_IN); } else if (success) { mVerifyStatus.setText(R.string.linked_verify_success); - mVerifyImage.setImageResource(R.drawable.status_signature_verified_cutout); + mVerifyImage.setImageResource(R.drawable.status_signature_verified_cutout_24px); mVerifyImage.setColorFilter(getResources().getColor(R.color.android_green_dark), PorterDuff.Mode.SRC_IN); } else { mVerifyStatus.setText(R.string.linked_verify_error); - mVerifyImage.setImageResource(R.drawable.status_signature_unknown_cutout); + mVerifyImage.setImageResource(R.drawable.status_signature_unknown_cutout_24px); mVerifyImage.setColorFilter(getResources().getColor(R.color.android_red_dark), PorterDuff.Mode.SRC_IN); } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java index 0d78bad27..6f25ef069 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java @@ -163,17 +163,17 @@ public class LinkedIdCreateHttpsStep2Fragment extends Fragment { mVerifyImage.setVisibility(on ? View.GONE : View.VISIBLE); if (success == null) { mVerifyStatus.setText(R.string.linked_verifying); - mVerifyImage.setImageResource(R.drawable.status_signature_unverified_cutout); + mVerifyImage.setImageResource(R.drawable.status_signature_unverified_cutout_24px); mVerifyImage.setColorFilter(getResources().getColor(R.color.tertiary_text_light), PorterDuff.Mode.SRC_IN); } else if (success) { mVerifyStatus.setText(R.string.linked_verify_success); - mVerifyImage.setImageResource(R.drawable.status_signature_verified_cutout); + mVerifyImage.setImageResource(R.drawable.status_signature_verified_cutout_24px); mVerifyImage.setColorFilter(getResources().getColor(R.color.android_green_dark), PorterDuff.Mode.SRC_IN); } else { mVerifyStatus.setText(R.string.linked_verify_error); - mVerifyImage.setImageResource(R.drawable.status_signature_unknown_cutout); + mVerifyImage.setImageResource(R.drawable.status_signature_unknown_cutout_24px); mVerifyImage.setColorFilter(getResources().getColor(R.color.android_red_dark), PorterDuff.Mode.SRC_IN); } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java index 23e50d9dc..f395807cf 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java @@ -144,17 +144,17 @@ public class LinkedIdCreateTwitterStep3Fragment extends Fragment { mVerifyImage.setVisibility(on ? View.GONE : View.VISIBLE); if (success == null) { mVerifyStatus.setText(R.string.linked_verifying); - mVerifyImage.setImageResource(R.drawable.status_signature_unverified_cutout); + mVerifyImage.setImageResource(R.drawable.status_signature_unverified_cutout_24px); mVerifyImage.setColorFilter(getResources().getColor(R.color.tertiary_text_light), PorterDuff.Mode.SRC_IN); } else if (success) { mVerifyStatus.setText(R.string.linked_verify_success); - mVerifyImage.setImageResource(R.drawable.status_signature_verified_cutout); + mVerifyImage.setImageResource(R.drawable.status_signature_verified_cutout_24px); mVerifyImage.setColorFilter(getResources().getColor(R.color.android_green_dark), PorterDuff.Mode.SRC_IN); } else { mVerifyStatus.setText(R.string.linked_verify_error); - mVerifyImage.setImageResource(R.drawable.status_signature_unknown_cutout); + mVerifyImage.setImageResource(R.drawable.status_signature_unknown_cutout_24px); mVerifyImage.setColorFilter(getResources().getColor(R.color.android_red_dark), PorterDuff.Mode.SRC_IN); } -- cgit v1.2.3 From 8bec183eda38e423706001b9f030600f47a5761e Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Mon, 2 Mar 2015 19:05:52 +0100 Subject: add linked it to view key context menu --- .../org/sufficientlysecure/keychain/ui/linked/LinkedIdWizard.java | 8 ++++++++ 1 file changed, 8 insertions(+) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdWizard.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdWizard.java index b8f3329c1..161efc8fb 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdWizard.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdWizard.java @@ -27,6 +27,7 @@ import org.sufficientlysecure.keychain.Constants; import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.pgp.exception.PgpKeyNotFoundException; import org.sufficientlysecure.keychain.provider.CachedPublicKeyRing; +import org.sufficientlysecure.keychain.provider.KeychainContract; import org.sufficientlysecure.keychain.provider.ProviderHelper; import org.sufficientlysecure.keychain.util.Log; @@ -47,7 +48,14 @@ public class LinkedIdWizard extends ActionBarActivity { try { Uri uri = getIntent().getData(); + uri = KeychainContract.KeyRings.buildUnifiedKeyRingUri(uri); CachedPublicKeyRing ring = new ProviderHelper(this).getCachedPublicKeyRing(uri); + if (!ring.hasAnySecret()) { + Log.e(Constants.TAG, "Linked Identities can only be added to secret keys!"); + finish(); + return; + } + mMasterKeyId = ring.extractOrGetMasterKeyId(); mFingerprint = ring.getFingerprint(); } catch (PgpKeyNotFoundException e) { -- cgit v1.2.3 From 8222315dbd1fe412ead71e0f12ba54b19705617c Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Wed, 4 Mar 2015 12:30:56 +0100 Subject: work more on separation of linked identities and resources, initial ui work --- .../keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java | 4 ++-- .../keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java | 10 +++++----- .../keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java | 4 ++-- .../keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java | 9 +++++---- .../keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java | 4 ++-- 5 files changed, 16 insertions(+), 15 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java index 973067246..14d5f3b5d 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java @@ -29,7 +29,7 @@ import android.view.ViewGroup; import android.widget.EditText; import org.sufficientlysecure.keychain.R; -import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; +import org.sufficientlysecure.keychain.pgp.linked.RawLinkedIdentity; import org.sufficientlysecure.keychain.pgp.linked.resources.DnsResource; public class LinkedIdCreateDnsStep1Fragment extends Fragment { @@ -73,7 +73,7 @@ public class LinkedIdCreateDnsStep1Fragment extends Fragment { return; } - String proofNonce = LinkedIdentity.generateNonce(); + String proofNonce = RawLinkedIdentity.generateNonce(); String proofText = DnsResource.generateText(getActivity(), mLinkedIdWizard.mFingerprint, proofNonce); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java index 3c413556d..6c9110ffd 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java @@ -33,7 +33,6 @@ import android.view.LayoutInflater; import android.view.View; import android.view.View.OnClickListener; import android.view.ViewGroup; -import android.widget.EditText; import android.widget.ImageView; import android.widget.TextView; @@ -42,7 +41,7 @@ import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.operations.results.LinkedVerifyResult; import org.sufficientlysecure.keychain.operations.results.OperationResult; import org.sufficientlysecure.keychain.pgp.WrappedUserAttribute; -import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; +import org.sufficientlysecure.keychain.pgp.linked.RawLinkedIdentity; import org.sufficientlysecure.keychain.pgp.linked.resources.DnsResource; import org.sufficientlysecure.keychain.service.KeychainIntentService; import org.sufficientlysecure.keychain.service.KeychainIntentServiceHandler; @@ -71,7 +70,8 @@ public class LinkedIdCreateDnsStep2Fragment extends Fragment { TextView mVerifyStatus; String mResourceDomain; - String mResourceNonce, mResourceString; + int mResourceNonce; + String mResourceString; // This is a resource, set AFTER it has been verified DnsResource mVerifiedResource = null; @@ -98,7 +98,7 @@ public class LinkedIdCreateDnsStep2Fragment extends Fragment { final View view = inflater.inflate(R.layout.linked_create_dns_fragment_step2, container, false); mResourceDomain = getArguments().getString(DOMAIN); - mResourceNonce = getArguments().getString(NONCE); + mResourceNonce = getArguments().getInt(NONCE); mResourceString = getArguments().getString(TEXT); view.findViewById(R.id.next_button).setOnClickListener(new OnClickListener() { @@ -308,7 +308,7 @@ public class LinkedIdCreateDnsStep2Fragment extends Fragment { new SaveKeyringParcel(mLinkedIdWizard.mMasterKeyId, mLinkedIdWizard.mFingerprint); WrappedUserAttribute ua = - LinkedIdentity.fromResource(mVerifiedResource, mResourceNonce).toUserAttribute(); + RawLinkedIdentity.fromResource(mVerifiedResource, mResourceNonce).toUserAttribute(); skp.mAddUserAttribute.add(ua); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java index 7c5f1f032..9fe1d43a3 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java @@ -29,7 +29,7 @@ import android.view.ViewGroup; import android.widget.EditText; import org.sufficientlysecure.keychain.R; -import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; +import org.sufficientlysecure.keychain.pgp.linked.RawLinkedIdentity; import org.sufficientlysecure.keychain.pgp.linked.resources.GenericHttpsResource; public class LinkedIdCreateHttpsStep1Fragment extends Fragment { @@ -72,7 +72,7 @@ public class LinkedIdCreateHttpsStep1Fragment extends Fragment { return; } - String proofNonce = LinkedIdentity.generateNonce(); + String proofNonce = RawLinkedIdentity.generateNonce(); String proofText = GenericHttpsResource.generateText(getActivity(), mLinkedIdWizard.mFingerprint, proofNonce); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java index 6f25ef069..f3fcc4410 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java @@ -42,7 +42,7 @@ import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.operations.results.LinkedVerifyResult; import org.sufficientlysecure.keychain.operations.results.OperationResult; import org.sufficientlysecure.keychain.pgp.WrappedUserAttribute; -import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; +import org.sufficientlysecure.keychain.pgp.linked.RawLinkedIdentity; import org.sufficientlysecure.keychain.pgp.linked.resources.GenericHttpsResource; import org.sufficientlysecure.keychain.service.KeychainIntentService; import org.sufficientlysecure.keychain.service.KeychainIntentServiceHandler; @@ -73,7 +73,8 @@ public class LinkedIdCreateHttpsStep2Fragment extends Fragment { TextView mVerifyStatus; String mResourceUri; - String mResourceNonce, mResourceString; + int mResourceNonce; + String mResourceString; // This is a resource, set AFTER it has been verified GenericHttpsResource mVerifiedResource = null; @@ -100,7 +101,7 @@ public class LinkedIdCreateHttpsStep2Fragment extends Fragment { final View view = inflater.inflate(R.layout.linked_create_https_fragment_step2, container, false); mResourceUri = getArguments().getString(URI); - mResourceNonce = getArguments().getString(NONCE); + mResourceNonce = getArguments().getInt(NONCE); mResourceString = getArguments().getString(TEXT); view.findViewById(R.id.next_button).setOnClickListener(new OnClickListener() { @@ -314,7 +315,7 @@ public class LinkedIdCreateHttpsStep2Fragment extends Fragment { new SaveKeyringParcel(mLinkedIdWizard.mMasterKeyId, mLinkedIdWizard.mFingerprint); WrappedUserAttribute ua = - LinkedIdentity.fromResource(mVerifiedResource, mResourceNonce).toUserAttribute(); + RawLinkedIdentity.fromResource(mVerifiedResource, mResourceNonce).toUserAttribute(); skp.mAddUserAttribute.add(ua); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java index 25a4f6463..8113525be 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java @@ -27,7 +27,7 @@ import android.view.ViewGroup; import android.widget.EditText; import org.sufficientlysecure.keychain.R; -import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; +import org.sufficientlysecure.keychain.pgp.linked.RawLinkedIdentity; import org.sufficientlysecure.keychain.pgp.linked.resources.TwitterResource; import org.sufficientlysecure.keychain.ui.util.Notify; @@ -92,7 +92,7 @@ public class LinkedIdCreateTwitterStep1Fragment extends Fragment { return; } - String proofNonce = LinkedIdentity.generateNonce(); + String proofNonce = RawLinkedIdentity.generateNonce(); String proofText = TwitterResource.generateText(getActivity(), mLinkedIdWizard.mFingerprint, proofNonce); -- cgit v1.2.3 From 1f324be24316175a111b9424a22fc5fcb6104e2b Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Thu, 5 Mar 2015 01:58:36 +0100 Subject: do a TON of UI work --- .../ui/linked/LinkedIdCreateDnsStep1Fragment.java | 2 +- .../ui/linked/LinkedIdCreateDnsStep2Fragment.java | 8 ++-- .../linked/LinkedIdCreateHttpsStep1Fragment.java | 2 +- .../linked/LinkedIdCreateHttpsStep2Fragment.java | 7 ++-- .../linked/LinkedIdCreateTwitterStep1Fragment.java | 2 +- .../linked/LinkedIdCreateTwitterStep2Fragment.java | 4 +- .../keychain/ui/linked/LinkedIdViewFragment.java | 45 ++++++++++++++++++++++ 7 files changed, 59 insertions(+), 11 deletions(-) create mode 100644 OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java index 14d5f3b5d..26b0a0539 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java @@ -73,7 +73,7 @@ public class LinkedIdCreateDnsStep1Fragment extends Fragment { return; } - String proofNonce = RawLinkedIdentity.generateNonce(); + int proofNonce = RawLinkedIdentity.generateNonce(); String proofText = DnsResource.generateText(getActivity(), mLinkedIdWizard.mFingerprint, proofNonce); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java index 6c9110ffd..71a3673f2 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java @@ -41,6 +41,7 @@ import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.operations.results.LinkedVerifyResult; import org.sufficientlysecure.keychain.operations.results.OperationResult; import org.sufficientlysecure.keychain.pgp.WrappedUserAttribute; +import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; import org.sufficientlysecure.keychain.pgp.linked.RawLinkedIdentity; import org.sufficientlysecure.keychain.pgp.linked.resources.DnsResource; import org.sufficientlysecure.keychain.service.KeychainIntentService; @@ -80,13 +81,13 @@ public class LinkedIdCreateDnsStep2Fragment extends Fragment { * Creates new instance of this fragment */ public static LinkedIdCreateDnsStep2Fragment newInstance - (String uri, String proofNonce, String proofText) { + (String uri, int proofNonce, String proofText) { LinkedIdCreateDnsStep2Fragment frag = new LinkedIdCreateDnsStep2Fragment(); Bundle args = new Bundle(); args.putString(DOMAIN, uri); - args.putString(NONCE, proofNonce); + args.putInt(NONCE, proofNonce); args.putString(TEXT, proofText); frag.setArguments(args); @@ -237,6 +238,7 @@ public class LinkedIdCreateDnsStep2Fragment extends Fragment { mVerifiedResource = resource; } else { setVerifyProgress(false, false); + mVerifiedResource = resource; // on error, show error message result.createNotify(getActivity()).show(); } @@ -308,7 +310,7 @@ public class LinkedIdCreateDnsStep2Fragment extends Fragment { new SaveKeyringParcel(mLinkedIdWizard.mMasterKeyId, mLinkedIdWizard.mFingerprint); WrappedUserAttribute ua = - RawLinkedIdentity.fromResource(mVerifiedResource, mResourceNonce).toUserAttribute(); + LinkedIdentity.fromResource(mVerifiedResource, mResourceNonce).toUserAttribute(); skp.mAddUserAttribute.add(ua); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java index 9fe1d43a3..78ca4cfe9 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java @@ -72,7 +72,7 @@ public class LinkedIdCreateHttpsStep1Fragment extends Fragment { return; } - String proofNonce = RawLinkedIdentity.generateNonce(); + int proofNonce = RawLinkedIdentity.generateNonce(); String proofText = GenericHttpsResource.generateText(getActivity(), mLinkedIdWizard.mFingerprint, proofNonce); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java index f3fcc4410..78c7caf53 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java @@ -42,6 +42,7 @@ import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.operations.results.LinkedVerifyResult; import org.sufficientlysecure.keychain.operations.results.OperationResult; import org.sufficientlysecure.keychain.pgp.WrappedUserAttribute; +import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; import org.sufficientlysecure.keychain.pgp.linked.RawLinkedIdentity; import org.sufficientlysecure.keychain.pgp.linked.resources.GenericHttpsResource; import org.sufficientlysecure.keychain.service.KeychainIntentService; @@ -83,13 +84,13 @@ public class LinkedIdCreateHttpsStep2Fragment extends Fragment { * Creates new instance of this fragment */ public static LinkedIdCreateHttpsStep2Fragment newInstance - (String uri, String proofNonce, String proofText) { + (String uri, int proofNonce, String proofText) { LinkedIdCreateHttpsStep2Fragment frag = new LinkedIdCreateHttpsStep2Fragment(); Bundle args = new Bundle(); args.putString(URI, uri); - args.putString(NONCE, proofNonce); + args.putInt(NONCE, proofNonce); args.putString(TEXT, proofText); frag.setArguments(args); @@ -315,7 +316,7 @@ public class LinkedIdCreateHttpsStep2Fragment extends Fragment { new SaveKeyringParcel(mLinkedIdWizard.mMasterKeyId, mLinkedIdWizard.mFingerprint); WrappedUserAttribute ua = - RawLinkedIdentity.fromResource(mVerifiedResource, mResourceNonce).toUserAttribute(); + LinkedIdentity.fromResource(mVerifiedResource, mResourceNonce).toUserAttribute(); skp.mAddUserAttribute.add(ua); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java index 8113525be..e966fd71f 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java @@ -92,7 +92,7 @@ public class LinkedIdCreateTwitterStep1Fragment extends Fragment { return; } - String proofNonce = RawLinkedIdentity.generateNonce(); + int proofNonce = RawLinkedIdentity.generateNonce(); String proofText = TwitterResource.generateText(getActivity(), mLinkedIdWizard.mFingerprint, proofNonce); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java index ab56e7a5d..837b84d40 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java @@ -52,13 +52,13 @@ public class LinkedIdCreateTwitterStep2Fragment extends Fragment { * Creates new instance of this fragment */ public static LinkedIdCreateTwitterStep2Fragment newInstance - (String handle, String proofNonce, String proofText) { + (String handle, int proofNonce, String proofText) { LinkedIdCreateTwitterStep2Fragment frag = new LinkedIdCreateTwitterStep2Fragment(); Bundle args = new Bundle(); args.putString(HANDLE, handle); - args.putString(NONCE, proofNonce); + args.putInt(NONCE, proofNonce); args.putString(TEXT, proofText); frag.setArguments(args); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java new file mode 100644 index 000000000..0eb0dcd45 --- /dev/null +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -0,0 +1,45 @@ +package org.sufficientlysecure.keychain.ui.linked; + +import android.os.Bundle; +import android.support.v4.app.Fragment; +import android.support.v7.widget.CardView; +import android.view.LayoutInflater; +import android.view.View; +import android.view.View.OnClickListener; +import android.view.ViewGroup; + +import org.sufficientlysecure.keychain.R; +import org.sufficientlysecure.keychain.pgp.linked.RawLinkedIdentity; + + +public class LinkedIdViewFragment extends Fragment { + + private CardView mLinkedIdsCard; + + public static Fragment newInstance(RawLinkedIdentity id) { + LinkedIdViewFragment frag = new LinkedIdViewFragment(); + + Bundle args = new Bundle(); + frag.setArguments(args); + + return frag; + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup superContainer, Bundle savedInstanceState) { + View root = inflater.inflate(R.layout.linked_id_view_fragment, null); + + mLinkedIdsCard = (CardView) root.findViewById(R.id.card_linked_ids); + + root.findViewById(R.id.back_button).setClickable(true); + root.findViewById(R.id.back_button).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + getFragmentManager().popBackStack(); + } + }); + + return root; + } + +} -- cgit v1.2.3 From a2419aa688afb61c02a1fcd4a8d1df46fdd97b5e Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Thu, 5 Mar 2015 18:05:48 +0100 Subject: work on LinkedIdViewFragment --- .../keychain/ui/linked/LinkedIdViewFragment.java | 121 ++++++++++++++++++++- 1 file changed, 116 insertions(+), 5 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index 0eb0dcd45..b526776f0 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -1,5 +1,9 @@ package org.sufficientlysecure.keychain.ui.linked; +import java.io.IOException; + +import android.content.Context; +import android.content.Intent; import android.os.Bundle; import android.support.v4.app.Fragment; import android.support.v7.widget.CardView; @@ -9,17 +13,61 @@ import android.view.View.OnClickListener; import android.view.ViewGroup; import org.sufficientlysecure.keychain.R; +import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; +import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; +import org.sufficientlysecure.keychain.pgp.linked.LinkedResource; import org.sufficientlysecure.keychain.pgp.linked.RawLinkedIdentity; +import org.sufficientlysecure.keychain.provider.KeychainContract.Certs; +import org.sufficientlysecure.keychain.ui.adapter.LinkedIdsAdapter.ViewHolder; +import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils; +import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils.State; public class LinkedIdViewFragment extends Fragment { - private CardView mLinkedIdsCard; + private static final String EXTRA_ENCODED_LID = "encoded_lid"; + private static final String EXTRA_VERIFIED = "verified"; + + private RawLinkedIdentity mLinkedId; + private LinkedCookieResource mLinkedResource; + private Integer mVerified; + + private CardView vLinkedIdsCard; + private Context mContext; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + + Bundle args = getArguments(); + byte[] data = args.getByteArray(EXTRA_ENCODED_LID); + + try { + mLinkedId = LinkedIdentity.fromAttributeData(data); + } catch (IOException e) { + // TODO um… + e.printStackTrace(); + throw new AssertionError("reconstruction of user attribute must succeed!"); + } - public static Fragment newInstance(RawLinkedIdentity id) { + if (mLinkedId instanceof LinkedIdentity) { + LinkedResource res = ((LinkedIdentity) mLinkedId).mResource; + mLinkedResource = (LinkedCookieResource) res; + } + + mVerified = args.containsKey(EXTRA_VERIFIED) ? args.getInt(EXTRA_VERIFIED) : null; + + mContext = getActivity(); + } + + public static Fragment newInstance(RawLinkedIdentity id, Integer isVerified) throws IOException { LinkedIdViewFragment frag = new LinkedIdViewFragment(); Bundle args = new Bundle(); + args.putByteArray(EXTRA_ENCODED_LID, id.toUserAttribute().getEncoded()); + if (isVerified != null) { + args.putInt(EXTRA_VERIFIED, isVerified); + } frag.setArguments(args); return frag; @@ -29,17 +77,80 @@ public class LinkedIdViewFragment extends Fragment { public View onCreateView(LayoutInflater inflater, ViewGroup superContainer, Bundle savedInstanceState) { View root = inflater.inflate(R.layout.linked_id_view_fragment, null); - mLinkedIdsCard = (CardView) root.findViewById(R.id.card_linked_ids); + vLinkedIdsCard = (CardView) root.findViewById(R.id.card_linked_ids); - root.findViewById(R.id.back_button).setClickable(true); - root.findViewById(R.id.back_button).setOnClickListener(new OnClickListener() { + View back = root.findViewById(R.id.back_button); + back.setClickable(true); + back.findViewById(R.id.back_button).setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { getFragmentManager().popBackStack(); } }); + ViewHolder holder = new ViewHolder(root); + + if (mVerified != null) { + holder.vVerified.setVisibility(View.VISIBLE); + switch (mVerified) { + case Certs.VERIFIED_SECRET: + KeyFormattingUtils.setStatusImage(mContext, holder.vVerified, + null, State.VERIFIED, KeyFormattingUtils.DEFAULT_COLOR); + break; + case Certs.VERIFIED_SELF: + KeyFormattingUtils.setStatusImage(mContext, holder.vVerified, + null, State.UNVERIFIED, KeyFormattingUtils.DEFAULT_COLOR); + break; + default: + KeyFormattingUtils.setStatusImage(mContext, holder.vVerified, + null, State.INVALID, KeyFormattingUtils.DEFAULT_COLOR); + break; + } + } else { + holder.vVerified.setVisibility(View.GONE); + } + + holder.setData(mContext, mLinkedId); + + // no resource, nothing further we can do… + if (mLinkedResource == null) { + root.findViewById(R.id.button_view).setVisibility(View.GONE); + root.findViewById(R.id.button_verify).setVisibility(View.GONE); + return root; + } + + View button_view = root.findViewById(R.id.button_view); + if (mLinkedResource.isViewable()) { + button_view.setVisibility(View.VISIBLE); + button_view.setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + Intent intent = mLinkedResource.getViewIntent(); + if (intent == null) { + return; + } + getActivity().startActivity(intent); + } + }); + } else { + button_view.setVisibility(View.GONE); + } + + View button_verify = root.findViewById(R.id.button_verify); + button_verify.setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + verifyResource(); + } + }); + return root; } + public void verifyResource() { + + // TODO + + } + } -- cgit v1.2.3 From 6e17d5244dcbfaad5c4de902e1f4c2cd913fd596 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Fri, 6 Mar 2015 14:20:58 +0100 Subject: first steps in ui towards confirmation of linked ids --- .../keychain/ui/linked/LinkedIdViewFragment.java | 116 +++++++++++++++++++-- 1 file changed, 108 insertions(+), 8 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index b526776f0..5cf0ed115 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -4,6 +4,7 @@ import java.io.IOException; import android.content.Context; import android.content.Intent; +import android.os.AsyncTask; import android.os.Bundle; import android.support.v4.app.Fragment; import android.support.v7.widget.CardView; @@ -11,8 +12,13 @@ import android.view.LayoutInflater; import android.view.View; import android.view.View.OnClickListener; import android.view.ViewGroup; +import android.widget.ImageView; +import android.widget.LinearLayout; +import android.widget.TextView; +import android.widget.ViewAnimator; import org.sufficientlysecure.keychain.R; +import org.sufficientlysecure.keychain.operations.results.LinkedVerifyResult; import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; import org.sufficientlysecure.keychain.pgp.linked.LinkedResource; @@ -21,12 +27,15 @@ import org.sufficientlysecure.keychain.provider.KeychainContract.Certs; import org.sufficientlysecure.keychain.ui.adapter.LinkedIdsAdapter.ViewHolder; import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils; import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils.State; +import org.sufficientlysecure.keychain.ui.util.Notify; +import org.sufficientlysecure.keychain.ui.util.Notify.Style; public class LinkedIdViewFragment extends Fragment { - private static final String EXTRA_ENCODED_LID = "encoded_lid"; - private static final String EXTRA_VERIFIED = "verified"; + private static final String ARG_ENCODED_LID = "encoded_lid"; + private static final String ARG_VERIFIED = "verified"; + private static final String ARG_FINGERPRINT = "fingerprint"; private RawLinkedIdentity mLinkedId; private LinkedCookieResource mLinkedResource; @@ -34,13 +43,20 @@ public class LinkedIdViewFragment extends Fragment { private CardView vLinkedIdsCard; private Context mContext; + private byte[] mFingerprint; + private LayoutInflater mInflater; + private LinearLayout vLinkedCerts; + + private View mCurrentCert; + private boolean mInProgress; + private ViewAnimator mButtonSwitcher; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Bundle args = getArguments(); - byte[] data = args.getByteArray(EXTRA_ENCODED_LID); + byte[] data = args.getByteArray(ARG_ENCODED_LID); try { mLinkedId = LinkedIdentity.fromAttributeData(data); @@ -55,19 +71,24 @@ public class LinkedIdViewFragment extends Fragment { mLinkedResource = (LinkedCookieResource) res; } - mVerified = args.containsKey(EXTRA_VERIFIED) ? args.getInt(EXTRA_VERIFIED) : null; + mVerified = args.containsKey(ARG_VERIFIED) ? args.getInt(ARG_VERIFIED) : null; + mFingerprint = args.getByteArray(ARG_FINGERPRINT); mContext = getActivity(); + mInflater = getLayoutInflater(savedInstanceState); + } - public static Fragment newInstance(RawLinkedIdentity id, Integer isVerified) throws IOException { + public static Fragment newInstance(RawLinkedIdentity id, + Integer isVerified, byte[] fingerprint) throws IOException { LinkedIdViewFragment frag = new LinkedIdViewFragment(); Bundle args = new Bundle(); - args.putByteArray(EXTRA_ENCODED_LID, id.toUserAttribute().getEncoded()); + args.putByteArray(ARG_ENCODED_LID, id.toUserAttribute().getEncoded()); if (isVerified != null) { - args.putInt(EXTRA_VERIFIED, isVerified); + args.putInt(ARG_VERIFIED, isVerified); } + args.putByteArray(ARG_FINGERPRINT, fingerprint); frag.setArguments(args); return frag; @@ -78,6 +99,7 @@ public class LinkedIdViewFragment extends Fragment { View root = inflater.inflate(R.layout.linked_id_view_fragment, null); vLinkedIdsCard = (CardView) root.findViewById(R.id.card_linked_ids); + vLinkedCerts = (LinearLayout) root.findViewById(R.id.linked_id_certs); View back = root.findViewById(R.id.back_button); back.setClickable(true); @@ -136,6 +158,8 @@ public class LinkedIdViewFragment extends Fragment { button_view.setVisibility(View.GONE); } + mButtonSwitcher = (ViewAnimator) root.findViewById(R.id.button_animator); + View button_verify = root.findViewById(R.id.button_verify); button_verify.setOnClickListener(new OnClickListener() { @Override @@ -144,12 +168,88 @@ public class LinkedIdViewFragment extends Fragment { } }); + View button_retry = root.findViewById(R.id.button_retry); + button_retry.setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + verifyResource(); + } + }); + + View button_confirm = root.findViewById(R.id.button_confirm); + button_confirm.setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + Notify.createNotify(getActivity(), "confirmed!", Notify.LENGTH_LONG, Style.INFO).show(); + } + }); + return root; } + static class ViewHolderCert { + final ViewAnimator vProgress; + final ImageView vIcon; + final TextView vText; + + ViewHolderCert(View view) { + vProgress = (ViewAnimator) view.findViewById(R.id.linked_cert_progress); + vIcon = (ImageView) view.findViewById(R.id.linked_cert_icon); + vText = (TextView) view.findViewById(R.id.linked_cert_text); + } + void setShowProgress(boolean show) { + vProgress.setDisplayedChild(show ? 0 : 1); + } + } + public void verifyResource() { - // TODO + // only one at a time + synchronized (this) { + if (mInProgress) { + return; + } + mInProgress = true; + } + + // is there a current certification? if not create a new one + final ViewHolderCert holder; + if (mCurrentCert == null) { + mCurrentCert = mInflater.inflate(R.layout.linked_id_cert, null); + holder = new ViewHolderCert(mCurrentCert); + mCurrentCert.setTag(holder); + vLinkedCerts.addView(mCurrentCert); + } else { + holder = (ViewHolderCert) mCurrentCert.getTag(); + } + + holder.setShowProgress(true); + holder.vText.setText("Verifying…"); + + new AsyncTask() { + @Override + protected LinkedVerifyResult doInBackground(Void... params) { + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + // nvm + } + return mLinkedResource.verify(mFingerprint, mLinkedId.mNonce); + } + + @Override + protected void onPostExecute(LinkedVerifyResult result) { + holder.setShowProgress(false); + if (result.success()) { + mButtonSwitcher.setDisplayedChild(2); + holder.vText.setText("Ok"); + } else { + mButtonSwitcher.setDisplayedChild(1); + holder.vText.setText("Error"); + } + mInProgress = false; + } + }.execute(); } -- cgit v1.2.3 From a3ac2738ea6140c6a181f9b685249ad2f766f904 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Fri, 6 Mar 2015 16:24:48 +0100 Subject: prepare superclass extraction for final linked id creation fragment --- .../linked/LinkedIdCreateHttpsStep2Fragment.java | 55 +++++++++++----------- .../keychain/ui/linked/LinkedIdViewFragment.java | 13 +++-- 2 files changed, 38 insertions(+), 30 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java index 7d2f3dfdb..6a0c1cac0 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java @@ -42,6 +42,7 @@ import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.operations.results.LinkedVerifyResult; import org.sufficientlysecure.keychain.operations.results.OperationResult; import org.sufficientlysecure.keychain.pgp.WrappedUserAttribute; +import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; import org.sufficientlysecure.keychain.pgp.linked.RawLinkedIdentity; import org.sufficientlysecure.keychain.pgp.linked.resources.GenericHttpsResource; @@ -73,12 +74,12 @@ public class LinkedIdCreateHttpsStep2Fragment extends Fragment { View mVerifyProgress; TextView mVerifyStatus; - String mResourceUri; int mResourceNonce; + URI mResourceUri; String mResourceString; // This is a resource, set AFTER it has been verified - GenericHttpsResource mVerifiedResource = null; + LinkedCookieResource mVerifiedResource = null; /** * Creates new instance of this fragment @@ -97,13 +98,15 @@ public class LinkedIdCreateHttpsStep2Fragment extends Fragment { return frag; } + GenericHttpsResource getResource() { + return GenericHttpsResource.createNew(mResourceUri); + } + @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { final View view = inflater.inflate(R.layout.linked_create_https_fragment_step2, container, false); - mResourceUri = getArguments().getString(URI); mResourceNonce = getArguments().getInt(NONCE); - mResourceString = getArguments().getString(TEXT); view.findViewById(R.id.next_button).setOnClickListener(new OnClickListener() { @Override @@ -144,8 +147,10 @@ public class LinkedIdCreateHttpsStep2Fragment extends Fragment { } }); + mResourceString = getArguments().getString(TEXT); + mEditUri = (EditText) view.findViewById(R.id.linked_create_https_uri); - mEditUri.setText(mResourceUri); + mEditUri.setText(mResourceUri.toString()); setVerifyProgress(false, null); mVerifyStatus.setText(R.string.linked_verify_pending); @@ -224,32 +229,28 @@ public class LinkedIdCreateHttpsStep2Fragment extends Fragment { public void proofVerify() { setVerifyProgress(true, null); - try { - final GenericHttpsResource resource = GenericHttpsResource.createNew(new URI(mResourceUri)); + final LinkedCookieResource resource = getResource(); - new AsyncTask() { + new AsyncTask() { - @Override - protected LinkedVerifyResult doInBackground(Void... params) { - return resource.verify(mLinkedIdWizard.mFingerprint, mResourceNonce); - } + @Override + protected LinkedVerifyResult doInBackground(Void... params) { + return resource.verify(mLinkedIdWizard.mFingerprint, mResourceNonce); + } - @Override - protected void onPostExecute(LinkedVerifyResult result) { - super.onPostExecute(result); - if (result.success()) { - setVerifyProgress(false, true); - mVerifiedResource = resource; - } else { - setVerifyProgress(false, false); - // on error, show error message - result.createNotify(getActivity()).show(); - } + @Override + protected void onPostExecute(LinkedVerifyResult result) { + super.onPostExecute(result); + if (result.success()) { + setVerifyProgress(false, true); + mVerifiedResource = resource; + } else { + setVerifyProgress(false, false); + // on error, show error message + result.createNotify(getActivity()).show(); } - }.execute(); - } catch (URISyntaxException e) { - e.printStackTrace(); - } + } + }.execute(); } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index 5cf0ed115..fdc466f04 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -202,7 +202,14 @@ public class LinkedIdViewFragment extends Fragment { } } - public void verifyResource() { + void showButton(int which) { + if (mButtonSwitcher.getDisplayedChild() == which) { + return; + } + mButtonSwitcher.setDisplayedChild(which); + } + + void verifyResource() { // only one at a time synchronized (this) { @@ -241,10 +248,10 @@ public class LinkedIdViewFragment extends Fragment { protected void onPostExecute(LinkedVerifyResult result) { holder.setShowProgress(false); if (result.success()) { - mButtonSwitcher.setDisplayedChild(2); + showButton(2); holder.vText.setText("Ok"); } else { - mButtonSwitcher.setDisplayedChild(1); + showButton(1); holder.vText.setText("Error"); } mInProgress = false; -- cgit v1.2.3 From 088282483f57cf03d9ee75578cd9d3bf6a74a4d9 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Fri, 6 Mar 2015 16:30:36 +0100 Subject: extract linked id create final fragment superclass --- .../ui/linked/LinkedIdCreateFinalFragment.java | 249 +++++++++++++++++++++ .../linked/LinkedIdCreateHttpsStep2Fragment.java | 247 +++----------------- 2 files changed, 275 insertions(+), 221 deletions(-) create mode 100644 OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java new file mode 100644 index 000000000..b02d70b33 --- /dev/null +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java @@ -0,0 +1,249 @@ +package org.sufficientlysecure.keychain.ui.linked; + +import android.app.Activity; +import android.app.ProgressDialog; +import android.content.Intent; +import android.graphics.PorterDuff; +import android.os.AsyncTask; +import android.os.Bundle; +import android.os.Message; +import android.os.Messenger; +import android.support.v4.app.Fragment; +import android.view.LayoutInflater; +import android.view.View; +import android.view.View.OnClickListener; +import android.view.ViewGroup; +import android.widget.ImageView; +import android.widget.TextView; + +import org.sufficientlysecure.keychain.R; +import org.sufficientlysecure.keychain.operations.results.LinkedVerifyResult; +import org.sufficientlysecure.keychain.operations.results.OperationResult; +import org.sufficientlysecure.keychain.pgp.WrappedUserAttribute; +import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; +import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; +import org.sufficientlysecure.keychain.service.KeychainIntentService; +import org.sufficientlysecure.keychain.service.KeychainIntentServiceHandler; +import org.sufficientlysecure.keychain.service.SaveKeyringParcel; +import org.sufficientlysecure.keychain.ui.PassphraseDialogActivity; +import org.sufficientlysecure.keychain.ui.util.Notify; + +public abstract class LinkedIdCreateFinalFragment extends Fragment { + + public static final String ARG_NONCE = "nonce"; + protected static final int REQUEST_CODE_PASSPHRASE = 0x00007008; + + LinkedIdWizard mLinkedIdWizard; + + private ImageView mVerifyImage; + private View mVerifyProgress; + private TextView mVerifyStatus; + private int mResourceNonce; + + // This is a resource, set AFTER it has been verified + LinkedCookieResource mVerifiedResource = null; + + @Override + public void onActivityCreated(Bundle savedInstanceState) { + super.onActivityCreated(savedInstanceState); + + mLinkedIdWizard = (LinkedIdWizard) getActivity(); + + mResourceNonce = getArguments().getInt(ARG_NONCE); + } + + protected abstract View newView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState); + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + final View view = newView(inflater, container, savedInstanceState); + + view.findViewById(R.id.next_button).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + startCertify(); + } + }); + + view.findViewById(R.id.back_button).setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + mLinkedIdWizard.loadFragment(null, null, LinkedIdWizard.FRAG_ACTION_TO_LEFT); + } + }); + + mVerifyImage = (ImageView) view.findViewById(R.id.verify_image); + mVerifyProgress = view.findViewById(R.id.verify_progress); + mVerifyStatus = (TextView) view.findViewById(R.id.verify_status); + + view.findViewById(R.id.button_verify).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + proofVerify(); + } + }); + + setVerifyProgress(false, null); + mVerifyStatus.setText(R.string.linked_verify_pending); + + return view; + } + + + abstract LinkedCookieResource getResource(); + + private void setVerifyProgress(boolean on, Boolean success) { + mVerifyProgress.setVisibility(on ? View.VISIBLE : View.GONE); + mVerifyImage.setVisibility(on ? View.GONE : View.VISIBLE); + if (success == null) { + mVerifyStatus.setText(R.string.linked_verifying); + mVerifyImage.setImageResource(R.drawable.status_signature_unverified_cutout_24dp); + mVerifyImage.setColorFilter(getResources().getColor(R.color.tertiary_text_light), + PorterDuff.Mode.SRC_IN); + } else if (success) { + mVerifyStatus.setText(R.string.linked_verify_success); + mVerifyImage.setImageResource(R.drawable.status_signature_verified_cutout_24dp); + mVerifyImage.setColorFilter(getResources().getColor(R.color.android_green_dark), + PorterDuff.Mode.SRC_IN); + } else { + mVerifyStatus.setText(R.string.linked_verify_error); + mVerifyImage.setImageResource(R.drawable.status_signature_unknown_cutout_24dp); + mVerifyImage.setColorFilter(getResources().getColor(R.color.android_red_dark), + PorterDuff.Mode.SRC_IN); + } + } + + private void proofVerify() { + setVerifyProgress(true, null); + + final LinkedCookieResource resource = getResource(); + + new AsyncTask() { + + @Override + protected LinkedVerifyResult doInBackground(Void... params) { + return resource.verify(mLinkedIdWizard.mFingerprint, mResourceNonce); + } + + @Override + protected void onPostExecute(LinkedVerifyResult result) { + super.onPostExecute(result); + if (result.success()) { + setVerifyProgress(false, true); + mVerifiedResource = resource; + } else { + setVerifyProgress(false, false); + // on error, show error message + result.createNotify(getActivity()).show(); + } + } + }.execute(); + + } + + private void startCertify() { + + if (mVerifiedResource == null) { + Notify.showNotify(getActivity(), R.string.linked_need_verify, Notify.Style.ERROR); + return; + } + + Intent intent = new Intent(getActivity(), PassphraseDialogActivity.class); + intent.putExtra(PassphraseDialogActivity.EXTRA_SUBKEY_ID, mLinkedIdWizard.mMasterKeyId); + startActivityForResult(intent, REQUEST_CODE_PASSPHRASE); + + } + + private void certifyLinkedIdentity (String passphrase) { + KeychainIntentServiceHandler saveHandler = new KeychainIntentServiceHandler( + getActivity(), + getString(R.string.progress_saving), + ProgressDialog.STYLE_HORIZONTAL, + true) { + public void handleMessage(Message message) { + // handle messages by standard KeychainIntentServiceHandler first + super.handleMessage(message); + + if (message.arg1 == KeychainIntentServiceHandler.MESSAGE_OKAY) { + + // get returned data bundle + Bundle returnData = message.getData(); + if (returnData == null) { + return; + } + final OperationResult result = + returnData.getParcelable(OperationResult.EXTRA_RESULT); + if (result == null) { + return; + } + + // if bad -> display here! + if (!result.success()) { + result.createNotify(getActivity()).show(); + return; + } + + result.createNotify(getActivity()).show(); + + // if good -> finish, return result to showkey and display there! + // Intent intent = new Intent(); + // intent.putExtra(OperationResult.EXTRA_RESULT, result); + // getActivity().setResult(EditKeyActivity.RESULT_OK, intent); + + // AffirmationCreateHttpsStep3Fragment frag = + // AffirmationCreateHttpsStep3Fragment.newInstance( + // mResourceUri, mResourceNonce, mResourceString); + + // mAffirmationWizard.loadFragment(null, frag, AffirmationWizard.FRAG_ACTION_TO_RIGHT); + + } + } + }; + + SaveKeyringParcel skp = + new SaveKeyringParcel(mLinkedIdWizard.mMasterKeyId, mLinkedIdWizard.mFingerprint); + + WrappedUserAttribute ua = + LinkedIdentity.fromResource(mVerifiedResource, mResourceNonce).toUserAttribute(); + + skp.mAddUserAttribute.add(ua); + + // Send all information needed to service to import key in other thread + Intent intent = new Intent(getActivity(), KeychainIntentService.class); + intent.setAction(KeychainIntentService.ACTION_EDIT_KEYRING); + + // fill values for this action + Bundle data = new Bundle(); + data.putString(KeychainIntentService.EDIT_KEYRING_PASSPHRASE, passphrase); + data.putParcelable(KeychainIntentService.EDIT_KEYRING_PARCEL, skp); + intent.putExtra(KeychainIntentService.EXTRA_DATA, data); + + // Create a new Messenger for the communication back + Messenger messenger = new Messenger(saveHandler); + intent.putExtra(KeychainIntentService.EXTRA_MESSENGER, messenger); + + // show progress dialog + saveHandler.showProgressDialog(getActivity()); + + // start service with intent + getActivity().startService(intent); + + } + + + @Override + public void onActivityResult(int requestCode, int resultCode, Intent data) { + switch (requestCode) { + case REQUEST_CODE_PASSPHRASE: + if (resultCode == Activity.RESULT_OK && data != null) { + String passphrase = + data.getStringExtra(PassphraseDialogActivity.MESSAGE_DATA_PASSPHRASE); + certifyLinkedIdentity(passphrase); + } + break; + default: + super.onActivityResult(requestCode, resultCode, data); + } + } + +} diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java index 6a0c1cac0..adae7eaf5 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java @@ -17,39 +17,20 @@ package org.sufficientlysecure.keychain.ui.linked; -import android.app.Activity; -import android.app.ProgressDialog; import android.content.Intent; -import android.graphics.PorterDuff; import android.net.Uri; -import android.os.AsyncTask; import android.os.Build; import android.os.Bundle; import android.os.Environment; -import android.os.Message; -import android.os.Messenger; -import android.support.v4.app.Fragment; import android.view.LayoutInflater; import android.view.View; import android.view.View.OnClickListener; import android.view.ViewGroup; import android.widget.EditText; -import android.widget.ImageView; -import android.widget.TextView; import org.sufficientlysecure.keychain.Constants; import org.sufficientlysecure.keychain.R; -import org.sufficientlysecure.keychain.operations.results.LinkedVerifyResult; -import org.sufficientlysecure.keychain.operations.results.OperationResult; -import org.sufficientlysecure.keychain.pgp.WrappedUserAttribute; -import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; -import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; -import org.sufficientlysecure.keychain.pgp.linked.RawLinkedIdentity; import org.sufficientlysecure.keychain.pgp.linked.resources.GenericHttpsResource; -import org.sufficientlysecure.keychain.service.KeychainIntentService; -import org.sufficientlysecure.keychain.service.KeychainIntentServiceHandler; -import org.sufficientlysecure.keychain.service.SaveKeyringParcel; -import org.sufficientlysecure.keychain.ui.PassphraseDialogActivity; import org.sufficientlysecure.keychain.ui.util.Notify; import org.sufficientlysecure.keychain.ui.util.Notify.Style; import org.sufficientlysecure.keychain.util.FileHelper; @@ -60,71 +41,59 @@ import java.io.PrintWriter; import java.net.URI; import java.net.URISyntaxException; -public class LinkedIdCreateHttpsStep2Fragment extends Fragment { +public class LinkedIdCreateHttpsStep2Fragment extends LinkedIdCreateFinalFragment { private static final int REQUEST_CODE_OUTPUT = 0x00007007; - private static final int REQUEST_CODE_PASSPHRASE = 0x00007008; - public static final String URI = "uri", NONCE = "nonce", TEXT = "text"; - - LinkedIdWizard mLinkedIdWizard; + public static final String ARG_URI = "uri", ARG_TEXT = "text"; EditText mEditUri; - ImageView mVerifyImage; - View mVerifyProgress; - TextView mVerifyStatus; - int mResourceNonce; URI mResourceUri; String mResourceString; - // This is a resource, set AFTER it has been verified - LinkedCookieResource mVerifiedResource = null; - - /** - * Creates new instance of this fragment - */ public static LinkedIdCreateHttpsStep2Fragment newInstance (String uri, int proofNonce, String proofText) { LinkedIdCreateHttpsStep2Fragment frag = new LinkedIdCreateHttpsStep2Fragment(); Bundle args = new Bundle(); - args.putString(URI, uri); - args.putInt(NONCE, proofNonce); - args.putString(TEXT, proofText); + args.putInt(ARG_NONCE, proofNonce); + args.putString(ARG_URI, uri); + args.putString(ARG_TEXT, proofText); frag.setArguments(args); return frag; } + @Override GenericHttpsResource getResource() { return GenericHttpsResource.createNew(mResourceUri); } @Override - public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { - final View view = inflater.inflate(R.layout.linked_create_https_fragment_step2, container, false); + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); - mResourceNonce = getArguments().getInt(NONCE); + try { + mResourceUri = new URI(getArguments().getString(ARG_URI)); + } catch (URISyntaxException e) { + e.printStackTrace(); + getActivity().finish(); + } - view.findViewById(R.id.next_button).setOnClickListener(new OnClickListener() { - @Override - public void onClick(View v) { - startCertify(); - } - }); + mResourceString = getArguments().getString(ARG_TEXT); - view.findViewById(R.id.back_button).setOnClickListener(new View.OnClickListener() { - @Override - public void onClick(View v) { - mLinkedIdWizard.loadFragment(null, null, LinkedIdWizard.FRAG_ACTION_TO_LEFT); - } - }); + } + + protected View newView(LayoutInflater inflater, + ViewGroup container, Bundle savedInstanceState) { + return inflater.inflate(R.layout.linked_create_https_fragment_step2, container, false); + } - mVerifyImage = (ImageView) view.findViewById(R.id.verify_image); - mVerifyProgress = view.findViewById(R.id.verify_progress); - mVerifyStatus = (TextView) view.findViewById(R.id.verify_status); + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + View view = super.onCreateView(inflater, container, savedInstanceState); view.findViewById(R.id.button_send).setOnClickListener(new OnClickListener() { @Override @@ -140,52 +109,12 @@ public class LinkedIdCreateHttpsStep2Fragment extends Fragment { } }); - view.findViewById(R.id.button_verify).setOnClickListener(new OnClickListener() { - @Override - public void onClick(View v) { - proofVerify(); - } - }); - - mResourceString = getArguments().getString(TEXT); - mEditUri = (EditText) view.findViewById(R.id.linked_create_https_uri); mEditUri.setText(mResourceUri.toString()); - setVerifyProgress(false, null); - mVerifyStatus.setText(R.string.linked_verify_pending); - return view; } - @Override - public void onActivityCreated(Bundle savedInstanceState) { - super.onActivityCreated(savedInstanceState); - - mLinkedIdWizard = (LinkedIdWizard) getActivity(); - } - - public void setVerifyProgress(boolean on, Boolean success) { - mVerifyProgress.setVisibility(on ? View.VISIBLE : View.GONE); - mVerifyImage.setVisibility(on ? View.GONE : View.VISIBLE); - if (success == null) { - mVerifyStatus.setText(R.string.linked_verifying); - mVerifyImage.setImageResource(R.drawable.status_signature_unverified_cutout_24dp); - mVerifyImage.setColorFilter(getResources().getColor(R.color.tertiary_text_light), - PorterDuff.Mode.SRC_IN); - } else if (success) { - mVerifyStatus.setText(R.string.linked_verify_success); - mVerifyImage.setImageResource(R.drawable.status_signature_verified_cutout_24dp); - mVerifyImage.setColorFilter(getResources().getColor(R.color.android_green_dark), - PorterDuff.Mode.SRC_IN); - } else { - mVerifyStatus.setText(R.string.linked_verify_error); - mVerifyImage.setImageResource(R.drawable.status_signature_unknown_cutout_24dp); - mVerifyImage.setColorFilter(getResources().getColor(R.color.android_red_dark), - PorterDuff.Mode.SRC_IN); - } - } - private void proofSend () { Intent sendIntent = new Intent(); sendIntent.setAction(Intent.ACTION_SEND); @@ -226,124 +155,6 @@ public class LinkedIdCreateHttpsStep2Fragment extends Fragment { } } - public void proofVerify() { - setVerifyProgress(true, null); - - final LinkedCookieResource resource = getResource(); - - new AsyncTask() { - - @Override - protected LinkedVerifyResult doInBackground(Void... params) { - return resource.verify(mLinkedIdWizard.mFingerprint, mResourceNonce); - } - - @Override - protected void onPostExecute(LinkedVerifyResult result) { - super.onPostExecute(result); - if (result.success()) { - setVerifyProgress(false, true); - mVerifiedResource = resource; - } else { - setVerifyProgress(false, false); - // on error, show error message - result.createNotify(getActivity()).show(); - } - } - }.execute(); - - } - - public void startCertify() { - - if (mVerifiedResource == null) { - Notify.showNotify(getActivity(), R.string.linked_need_verify, Notify.Style.ERROR); - return; - } - - Intent intent = new Intent(getActivity(), PassphraseDialogActivity.class); - intent.putExtra(PassphraseDialogActivity.EXTRA_SUBKEY_ID, mLinkedIdWizard.mMasterKeyId); - startActivityForResult(intent, REQUEST_CODE_PASSPHRASE); - - } - - public void certifyLinkedIdentity (String passphrase) { - KeychainIntentServiceHandler saveHandler = new KeychainIntentServiceHandler( - getActivity(), - getString(R.string.progress_saving), - ProgressDialog.STYLE_HORIZONTAL, - true) { - public void handleMessage(Message message) { - // handle messages by standard KeychainIntentServiceHandler first - super.handleMessage(message); - - if (message.arg1 == KeychainIntentServiceHandler.MESSAGE_OKAY) { - - // get returned data bundle - Bundle returnData = message.getData(); - if (returnData == null) { - return; - } - final OperationResult result = - returnData.getParcelable(OperationResult.EXTRA_RESULT); - if (result == null) { - return; - } - - // if bad -> display here! - if (!result.success()) { - result.createNotify(getActivity()).show(); - return; - } - - result.createNotify(getActivity()).show(); - - // if good -> finish, return result to showkey and display there! - // Intent intent = new Intent(); - // intent.putExtra(OperationResult.EXTRA_RESULT, result); - // getActivity().setResult(EditKeyActivity.RESULT_OK, intent); - - // AffirmationCreateHttpsStep3Fragment frag = - // AffirmationCreateHttpsStep3Fragment.newInstance( - // mResourceUri, mResourceNonce, mResourceString); - - // mAffirmationWizard.loadFragment(null, frag, AffirmationWizard.FRAG_ACTION_TO_RIGHT); - - } - } - }; - - SaveKeyringParcel skp = - new SaveKeyringParcel(mLinkedIdWizard.mMasterKeyId, mLinkedIdWizard.mFingerprint); - - WrappedUserAttribute ua = - LinkedIdentity.fromResource(mVerifiedResource, mResourceNonce).toUserAttribute(); - - skp.mAddUserAttribute.add(ua); - - // Send all information needed to service to import key in other thread - Intent intent = new Intent(getActivity(), KeychainIntentService.class); - intent.setAction(KeychainIntentService.ACTION_EDIT_KEYRING); - - // fill values for this action - Bundle data = new Bundle(); - data.putString(KeychainIntentService.EDIT_KEYRING_PASSPHRASE, passphrase); - data.putParcelable(KeychainIntentService.EDIT_KEYRING_PARCEL, skp); - intent.putExtra(KeychainIntentService.EXTRA_DATA, data); - - // Create a new Messenger for the communication back - Messenger messenger = new Messenger(saveHandler); - intent.putExtra(KeychainIntentService.EXTRA_MESSENGER, messenger); - - // show progress dialog - saveHandler.showProgressDialog(getActivity()); - - // start service with intent - getActivity().startService(intent); - - } - - @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { switch (requestCode) { @@ -355,15 +166,9 @@ public class LinkedIdCreateHttpsStep2Fragment extends Fragment { Uri uri = data.getData(); saveFile(uri); break; - case REQUEST_CODE_PASSPHRASE: - if (resultCode == Activity.RESULT_OK && data != null) { - String passphrase = - data.getStringExtra(PassphraseDialogActivity.MESSAGE_DATA_PASSPHRASE); - certifyLinkedIdentity(passphrase); - } - break; + default: + super.onActivityResult(requestCode, resultCode, data); } - super.onActivityResult(requestCode, resultCode, data); } } -- cgit v1.2.3 From 73ba19460b2eeb75566bb55df14bb5916d72b3b2 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Fri, 6 Mar 2015 16:49:40 +0100 Subject: use final fragment superclass for dns --- .../ui/linked/LinkedIdCreateDnsStep2Fragment.java | 231 ++------------------- .../ui/linked/LinkedIdCreateFinalFragment.java | 2 +- 2 files changed, 19 insertions(+), 214 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java index 3b0860fa9..de3a63256 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java @@ -17,37 +17,21 @@ package org.sufficientlysecure.keychain.ui.linked; -import android.app.Activity; -import android.app.ProgressDialog; import android.content.Intent; -import android.graphics.PorterDuff; import android.net.Uri; -import android.os.AsyncTask; import android.os.Build; import android.os.Bundle; import android.os.Environment; -import android.os.Message; -import android.os.Messenger; -import android.support.v4.app.Fragment; import android.view.LayoutInflater; import android.view.View; import android.view.View.OnClickListener; import android.view.ViewGroup; -import android.widget.ImageView; import android.widget.TextView; import org.sufficientlysecure.keychain.Constants; import org.sufficientlysecure.keychain.R; -import org.sufficientlysecure.keychain.operations.results.LinkedVerifyResult; -import org.sufficientlysecure.keychain.operations.results.OperationResult; -import org.sufficientlysecure.keychain.pgp.WrappedUserAttribute; -import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; -import org.sufficientlysecure.keychain.pgp.linked.RawLinkedIdentity; +import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; import org.sufficientlysecure.keychain.pgp.linked.resources.DnsResource; -import org.sufficientlysecure.keychain.service.KeychainIntentService; -import org.sufficientlysecure.keychain.service.KeychainIntentServiceHandler; -import org.sufficientlysecure.keychain.service.SaveKeyringParcel; -import org.sufficientlysecure.keychain.ui.PassphraseDialogActivity; import org.sufficientlysecure.keychain.ui.util.Notify; import org.sufficientlysecure.keychain.ui.util.Notify.Style; import org.sufficientlysecure.keychain.util.FileHelper; @@ -56,38 +40,25 @@ import java.io.File; import java.io.FileNotFoundException; import java.io.PrintWriter; -public class LinkedIdCreateDnsStep2Fragment extends Fragment { +public class LinkedIdCreateDnsStep2Fragment extends LinkedIdCreateFinalFragment { private static final int REQUEST_CODE_OUTPUT = 0x00007007; - private static final int REQUEST_CODE_PASSPHRASE = 0x00007008; - public static final String DOMAIN = "domain", NONCE = "nonce", TEXT = "text"; - - LinkedIdWizard mLinkedIdWizard; + public static final String DOMAIN = "domain", TEXT = "text"; TextView mTextView; - ImageView mVerifyImage; - View mVerifyProgress; - TextView mVerifyStatus; String mResourceDomain; - int mResourceNonce; String mResourceString; - // This is a resource, set AFTER it has been verified - DnsResource mVerifiedResource = null; - - /** - * Creates new instance of this fragment - */ public static LinkedIdCreateDnsStep2Fragment newInstance (String uri, int proofNonce, String proofText) { LinkedIdCreateDnsStep2Fragment frag = new LinkedIdCreateDnsStep2Fragment(); Bundle args = new Bundle(); + args.putInt(ARG_NONCE, proofNonce); args.putString(DOMAIN, uri); - args.putInt(NONCE, proofNonce); args.putString(TEXT, proofText); frag.setArguments(args); @@ -95,30 +66,22 @@ public class LinkedIdCreateDnsStep2Fragment extends Fragment { } @Override - public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { - final View view = inflater.inflate(R.layout.linked_create_dns_fragment_step2, container, false); + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); mResourceDomain = getArguments().getString(DOMAIN); - mResourceNonce = getArguments().getInt(NONCE); mResourceString = getArguments().getString(TEXT); - view.findViewById(R.id.next_button).setOnClickListener(new OnClickListener() { - @Override - public void onClick(View v) { - startCertify(); - } - }); + } - view.findViewById(R.id.back_button).setOnClickListener(new OnClickListener() { - @Override - public void onClick(View v) { - mLinkedIdWizard.loadFragment(null, null, LinkedIdWizard.FRAG_ACTION_TO_LEFT); - } - }); + @Override + protected View newView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + return inflater.inflate(R.layout.linked_create_dns_fragment_step2, container, false); + } - mVerifyImage = (ImageView) view.findViewById(R.id.verify_image); - mVerifyProgress = view.findViewById(R.id.verify_progress); - mVerifyStatus = (TextView) view.findViewById(R.id.verify_status); + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + View view = super.onCreateView(inflater, container, savedInstanceState); view.findViewById(R.id.button_send).setOnClickListener(new OnClickListener() { @Override @@ -134,48 +97,15 @@ public class LinkedIdCreateDnsStep2Fragment extends Fragment { } }); - view.findViewById(R.id.button_verify).setOnClickListener(new OnClickListener() { - @Override - public void onClick(View v) { - proofVerify(); - } - }); - mTextView = (TextView) view.findViewById(R.id.linked_create_dns_text); mTextView.setText(mResourceString); - setVerifyProgress(false, null); - mVerifyStatus.setText(R.string.linked_verify_pending); - return view; } @Override - public void onActivityCreated(Bundle savedInstanceState) { - super.onActivityCreated(savedInstanceState); - - mLinkedIdWizard = (LinkedIdWizard) getActivity(); - } - - public void setVerifyProgress(boolean on, Boolean success) { - mVerifyProgress.setVisibility(on ? View.VISIBLE : View.GONE); - mVerifyImage.setVisibility(on ? View.GONE : View.VISIBLE); - if (success == null) { - mVerifyStatus.setText(R.string.linked_verifying); - mVerifyImage.setImageResource(R.drawable.status_signature_unverified_cutout_24dp); - mVerifyImage.setColorFilter(getResources().getColor(R.color.tertiary_text_light), - PorterDuff.Mode.SRC_IN); - } else if (success) { - mVerifyStatus.setText(R.string.linked_verify_success); - mVerifyImage.setImageResource(R.drawable.status_signature_verified_cutout_24dp); - mVerifyImage.setColorFilter(getResources().getColor(R.color.android_green_dark), - PorterDuff.Mode.SRC_IN); - } else { - mVerifyStatus.setText(R.string.linked_verify_error); - mVerifyImage.setImageResource(R.drawable.status_signature_unknown_cutout_24dp); - mVerifyImage.setColorFilter(getResources().getColor(R.color.android_red_dark), - PorterDuff.Mode.SRC_IN); - } + LinkedCookieResource getResource() { + return DnsResource.createNew(mResourceDomain); } private void proofSend () { @@ -218,125 +148,6 @@ public class LinkedIdCreateDnsStep2Fragment extends Fragment { } } - public void proofVerify() { - setVerifyProgress(true, null); - - final DnsResource resource = DnsResource.createNew(mResourceDomain); - - new AsyncTask() { - - @Override - protected LinkedVerifyResult doInBackground(Void... params) { - return resource.verify(mLinkedIdWizard.mFingerprint, mResourceNonce); - } - - @Override - protected void onPostExecute(LinkedVerifyResult result) { - super.onPostExecute(result); - if (result.success()) { - setVerifyProgress(false, true); - mVerifiedResource = resource; - } else { - setVerifyProgress(false, false); - mVerifiedResource = resource; - // on error, show error message - result.createNotify(getActivity()).show(); - } - } - }.execute(); - - } - - public void startCertify() { - - if (mVerifiedResource == null) { - Notify.showNotify(getActivity(), R.string.linked_need_verify, Style.ERROR); - return; - } - - Intent intent = new Intent(getActivity(), PassphraseDialogActivity.class); - intent.putExtra(PassphraseDialogActivity.EXTRA_SUBKEY_ID, mLinkedIdWizard.mMasterKeyId); - startActivityForResult(intent, REQUEST_CODE_PASSPHRASE); - - } - - public void certifyLinkedIdentity (String passphrase) { - KeychainIntentServiceHandler saveHandler = new KeychainIntentServiceHandler( - getActivity(), - getString(R.string.progress_saving), - ProgressDialog.STYLE_HORIZONTAL, - true) { - public void handleMessage(Message message) { - // handle messages by standard KeychainIntentServiceHandler first - super.handleMessage(message); - - if (message.arg1 == KeychainIntentServiceHandler.MESSAGE_OKAY) { - - // get returned data bundle - Bundle returnData = message.getData(); - if (returnData == null) { - return; - } - final OperationResult result = - returnData.getParcelable(OperationResult.EXTRA_RESULT); - if (result == null) { - return; - } - - // if bad -> display here! - if (!result.success()) { - result.createNotify(getActivity()).show(); - return; - } - - result.createNotify(getActivity()).show(); - - // if good -> finish, return result to showkey and display there! - // Intent intent = new Intent(); - // intent.putExtra(OperationResult.EXTRA_RESULT, result); - // getActivity().setResult(EditKeyActivity.RESULT_OK, intent); - - // AffirmationCreateHttpsStep3Fragment frag = - // AffirmationCreateHttpsStep3Fragment.newInstance( - // mResourceDomain, mResourceNonce, mResourceString); - - // mAffirmationWizard.loadFragment(null, frag, AffirmationWizard.FRAG_ACTION_TO_RIGHT); - - } - } - }; - - SaveKeyringParcel skp = - new SaveKeyringParcel(mLinkedIdWizard.mMasterKeyId, mLinkedIdWizard.mFingerprint); - - WrappedUserAttribute ua = - LinkedIdentity.fromResource(mVerifiedResource, mResourceNonce).toUserAttribute(); - - skp.mAddUserAttribute.add(ua); - - // Send all information needed to service to import key in other thread - Intent intent = new Intent(getActivity(), KeychainIntentService.class); - intent.setAction(KeychainIntentService.ACTION_EDIT_KEYRING); - - // fill values for this action - Bundle data = new Bundle(); - data.putString(KeychainIntentService.EDIT_KEYRING_PASSPHRASE, passphrase); - data.putParcelable(KeychainIntentService.EDIT_KEYRING_PARCEL, skp); - intent.putExtra(KeychainIntentService.EXTRA_DATA, data); - - // Create a new Messenger for the communication back - Messenger messenger = new Messenger(saveHandler); - intent.putExtra(KeychainIntentService.EXTRA_MESSENGER, messenger); - - // show progress dialog - saveHandler.showProgressDialog(getActivity()); - - // start service with intent - getActivity().startService(intent); - - } - - @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { switch (requestCode) { @@ -348,15 +159,9 @@ public class LinkedIdCreateDnsStep2Fragment extends Fragment { Uri uri = data.getData(); saveFile(uri); break; - case REQUEST_CODE_PASSPHRASE: - if (resultCode == Activity.RESULT_OK && data != null) { - String passphrase = - data.getStringExtra(PassphraseDialogActivity.MESSAGE_DATA_PASSPHRASE); - certifyLinkedIdentity(passphrase); - } - break; + default: + super.onActivityResult(requestCode, resultCode, data); } - super.onActivityResult(requestCode, resultCode, data); } } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java index b02d70b33..c8c0c1239 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java @@ -33,7 +33,7 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { public static final String ARG_NONCE = "nonce"; protected static final int REQUEST_CODE_PASSPHRASE = 0x00007008; - LinkedIdWizard mLinkedIdWizard; + private LinkedIdWizard mLinkedIdWizard; private ImageView mVerifyImage; private View mVerifyProgress; -- cgit v1.2.3 From 5840e9d2b68c44af706b7162fc60db999bf85958 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Fri, 6 Mar 2015 16:54:54 +0100 Subject: use final fragment superclass for twitter --- .../linked/LinkedIdCreateTwitterStep3Fragment.java | 121 ++++----------------- 1 file changed, 23 insertions(+), 98 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java index d298e8251..0c317004b 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java @@ -32,67 +32,54 @@ import android.widget.ImageView; import android.widget.TextView; import org.sufficientlysecure.keychain.R; +import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; import org.sufficientlysecure.keychain.ui.util.Notify; import java.util.List; -public class LinkedIdCreateTwitterStep3Fragment extends Fragment { +public class LinkedIdCreateTwitterStep3Fragment extends LinkedIdCreateFinalFragment { - public static final String HANDLE = "uri", NONCE = "nonce", TEXT = "text", CUSTOM = "custom"; - - LinkedIdWizard mLinkedIdWizard; + public static final String ARG_HANDLE = "uri", ARG_TEXT = "text", ARG_CUSTOM = "custom"; EditText mEditTweetPreview; - ImageView mVerifyImage; - View mVerifyProgress; - TextView mVerifyStatus; String mResourceHandle, mCustom, mFullString; - String mResourceNonce, mResourceString; + String mResourceString; - /** - * Creates new instance of this fragment - */ public static LinkedIdCreateTwitterStep3Fragment newInstance (String handle, String proofNonce, String proofText, String customText) { LinkedIdCreateTwitterStep3Fragment frag = new LinkedIdCreateTwitterStep3Fragment(); Bundle args = new Bundle(); - args.putString(HANDLE, handle); - args.putString(NONCE, proofNonce); - args.putString(TEXT, proofText); - args.putString(CUSTOM, customText); + args.putString(ARG_HANDLE, handle); + args.putString(ARG_NONCE, proofNonce); + args.putString(ARG_TEXT, proofText); + args.putString(ARG_CUSTOM, customText); frag.setArguments(args); return frag; } @Override - public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { - final View view = inflater.inflate(R.layout.linked_create_twitter_fragment_step3, container, false); + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); - mResourceHandle = getArguments().getString(HANDLE); - mResourceNonce = getArguments().getString(NONCE); - mResourceString = getArguments().getString(TEXT); - mCustom = getArguments().getString(CUSTOM); + mResourceHandle = getArguments().getString(ARG_HANDLE); + mResourceString = getArguments().getString(ARG_TEXT); + mCustom = getArguments().getString(ARG_CUSTOM); mFullString = mCustom.isEmpty() ? mResourceString : (mCustom + " " + mResourceString); - mVerifyImage = (ImageView) view.findViewById(R.id.verify_image); - mVerifyProgress = view.findViewById(R.id.verify_progress); - mVerifyStatus = (TextView) view.findViewById(R.id.verify_status); + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + View view = super.onCreateView(inflater, container, savedInstanceState); mEditTweetPreview = (EditText) view.findViewById(R.id.linked_create_twitter_preview); mEditTweetPreview.setText(mFullString); - view.findViewById(R.id.back_button).setOnClickListener(new View.OnClickListener() { - @Override - public void onClick(View v) { - mLinkedIdWizard.loadFragment(null, null, LinkedIdWizard.FRAG_ACTION_TO_LEFT); - } - }); - view.findViewById(R.id.button_send).setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { @@ -107,17 +94,6 @@ public class LinkedIdCreateTwitterStep3Fragment extends Fragment { } }); - view.findViewById(R.id.button_verify).setOnClickListener(new OnClickListener() { - @Override - public void onClick(View v) { - proofVerify(); - } - }); - - setVerifyProgress(false, null); - mVerifyStatus.setText(R.string.linked_verify_pending); - - view.findViewById(R.id.next_button).setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { @@ -133,64 +109,13 @@ public class LinkedIdCreateTwitterStep3Fragment extends Fragment { } @Override - public void onActivityCreated(Bundle savedInstanceState) { - super.onActivityCreated(savedInstanceState); - - mLinkedIdWizard = (LinkedIdWizard) getActivity(); + LinkedCookieResource getResource() { + return null; } - public void setVerifyProgress(boolean on, Boolean success) { - mVerifyProgress.setVisibility(on ? View.VISIBLE : View.GONE); - mVerifyImage.setVisibility(on ? View.GONE : View.VISIBLE); - if (success == null) { - mVerifyStatus.setText(R.string.linked_verifying); - mVerifyImage.setImageResource(R.drawable.status_signature_unverified_cutout_24dp); - mVerifyImage.setColorFilter(getResources().getColor(R.color.tertiary_text_light), - PorterDuff.Mode.SRC_IN); - } else if (success) { - mVerifyStatus.setText(R.string.linked_verify_success); - mVerifyImage.setImageResource(R.drawable.status_signature_verified_cutout_24dp); - mVerifyImage.setColorFilter(getResources().getColor(R.color.android_green_dark), - PorterDuff.Mode.SRC_IN); - } else { - mVerifyStatus.setText(R.string.linked_verify_error); - mVerifyImage.setImageResource(R.drawable.status_signature_unknown_cutout_24dp); - mVerifyImage.setColorFilter(getResources().getColor(R.color.android_red_dark), - PorterDuff.Mode.SRC_IN); - } - } - - public void proofVerify() { - setVerifyProgress(true, null); - - /* - try { - final TwitterResource resource = TwitterResource.createNew(new URI(mResourceHandle)); - - new AsyncTask() { - - @Override - protected LinkedVerifyResult doInBackground(Void... params) { - return resource.verify(mAffirmationWizard.mFingerprint, mResourceNonce); - } - - @Override - protected void onPostExecute(LinkedVerifyResult result) { - super.onPostExecute(result); - if (result.success()) { - setVerifyProgress(false, true); - } else { - setVerifyProgress(false, false); - // on error, show error message - result.createNotify(getActivity()).show(); - } - } - }.execute(); - } catch (URISyntaxException e) { - e.printStackTrace(); - } - */ - + @Override + protected View newView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + return inflater.inflate(R.layout.linked_create_twitter_fragment_step3, container, false); } private void proofShare() { -- cgit v1.2.3 From 9e930f0a10189bae12a70299aef07ae85221aadd Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Fri, 6 Mar 2015 16:57:17 +0100 Subject: finish after linked id creation --- .../keychain/ui/linked/LinkedIdCreateFinalFragment.java | 13 +------------ 1 file changed, 1 insertion(+), 12 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java index c8c0c1239..ef76bc9d2 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java @@ -183,18 +183,7 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { return; } - result.createNotify(getActivity()).show(); - - // if good -> finish, return result to showkey and display there! - // Intent intent = new Intent(); - // intent.putExtra(OperationResult.EXTRA_RESULT, result); - // getActivity().setResult(EditKeyActivity.RESULT_OK, intent); - - // AffirmationCreateHttpsStep3Fragment frag = - // AffirmationCreateHttpsStep3Fragment.newInstance( - // mResourceUri, mResourceNonce, mResourceString); - - // mAffirmationWizard.loadFragment(null, frag, AffirmationWizard.FRAG_ACTION_TO_RIGHT); + getActivity().finish(); } } -- cgit v1.2.3 From 581cad5b3f7b54fae652e2598b4e760eb19678d2 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Sun, 8 Mar 2015 00:59:16 +0100 Subject: work on certification step --- .../keychain/ui/linked/LinkedIdViewFragment.java | 96 ++++++++++++++++++++-- 1 file changed, 90 insertions(+), 6 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index fdc466f04..7f8f4da04 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -2,10 +2,14 @@ package org.sufficientlysecure.keychain.ui.linked; import java.io.IOException; +import android.app.Activity; +import android.app.ProgressDialog; import android.content.Context; import android.content.Intent; import android.os.AsyncTask; import android.os.Bundle; +import android.os.Message; +import android.os.Messenger; import android.support.v4.app.Fragment; import android.support.v7.widget.CardView; import android.view.LayoutInflater; @@ -17,18 +21,26 @@ import android.widget.LinearLayout; import android.widget.TextView; import android.widget.ViewAnimator; +import org.spongycastle.util.encoders.Hex; import org.sufficientlysecure.keychain.R; +import org.sufficientlysecure.keychain.operations.results.CertifyResult; import org.sufficientlysecure.keychain.operations.results.LinkedVerifyResult; import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; import org.sufficientlysecure.keychain.pgp.linked.LinkedResource; import org.sufficientlysecure.keychain.pgp.linked.RawLinkedIdentity; import org.sufficientlysecure.keychain.provider.KeychainContract.Certs; +import org.sufficientlysecure.keychain.service.CertifyActionsParcel; +import org.sufficientlysecure.keychain.service.CertifyActionsParcel.CertifyAction; +import org.sufficientlysecure.keychain.service.KeychainIntentService; +import org.sufficientlysecure.keychain.service.KeychainIntentServiceHandler; import org.sufficientlysecure.keychain.ui.adapter.LinkedIdsAdapter.ViewHolder; import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils; import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils.State; import org.sufficientlysecure.keychain.ui.util.Notify; import org.sufficientlysecure.keychain.ui.util.Notify.Style; +import org.sufficientlysecure.keychain.ui.widget.CertifyKeySpinner; +import org.sufficientlysecure.keychain.util.Preferences; public class LinkedIdViewFragment extends Fragment { @@ -36,6 +48,7 @@ public class LinkedIdViewFragment extends Fragment { private static final String ARG_ENCODED_LID = "encoded_lid"; private static final String ARG_VERIFIED = "verified"; private static final String ARG_FINGERPRINT = "fingerprint"; + private static final String ARG_MASTER_KEY_ID = "fingerprint"; private RawLinkedIdentity mLinkedId; private LinkedCookieResource mLinkedResource; @@ -50,6 +63,7 @@ public class LinkedIdViewFragment extends Fragment { private View mCurrentCert; private boolean mInProgress; private ViewAnimator mButtonSwitcher; + private CertifyKeySpinner vKeySpinner; @Override public void onCreate(Bundle savedInstanceState) { @@ -100,6 +114,7 @@ public class LinkedIdViewFragment extends Fragment { vLinkedIdsCard = (CardView) root.findViewById(R.id.card_linked_ids); vLinkedCerts = (LinearLayout) root.findViewById(R.id.linked_id_certs); + vKeySpinner = (CertifyKeySpinner) root.findViewById(R.id.cert_key_spinner); View back = root.findViewById(R.id.back_button); back.setClickable(true); @@ -180,7 +195,7 @@ public class LinkedIdViewFragment extends Fragment { button_confirm.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { - Notify.createNotify(getActivity(), "confirmed!", Notify.LENGTH_LONG, Style.INFO).show(); + certifyResource(); } }); @@ -230,26 +245,33 @@ public class LinkedIdViewFragment extends Fragment { holder = (ViewHolderCert) mCurrentCert.getTag(); } + vKeySpinner.setVisibility(View.GONE); holder.setShowProgress(true); holder.vText.setText("Verifying…"); new AsyncTask() { @Override protected LinkedVerifyResult doInBackground(Void... params) { - try { - Thread.sleep(1000); + long timer = System.currentTimeMillis(); + LinkedVerifyResult result = mLinkedResource.verify(mFingerprint, mLinkedId.mNonce); + + // ux flow: this operation should take at last a second + timer = System.currentTimeMillis() -timer; + if (timer < 1000) try { + Thread.sleep(1000 -timer); } catch (InterruptedException e) { - // nvm + // never mind } - return mLinkedResource.verify(mFingerprint, mLinkedId.mNonce); + + return result; } @Override protected void onPostExecute(LinkedVerifyResult result) { holder.setShowProgress(false); if (result.success()) { - showButton(2); holder.vText.setText("Ok"); + setupForConfirmation(); } else { showButton(1); holder.vText.setText("Error"); @@ -260,4 +282,66 @@ public class LinkedIdViewFragment extends Fragment { } + void setupForConfirmation() { + + // button is 'confirm' + showButton(2); + + vKeySpinner.setVisibility(View.VISIBLE); + + } + + private void certifyResource() { + + Bundle data = new Bundle(); + { + CertifyAction action = new CertifyAction(); + + // fill values for this action + CertifyActionsParcel parcel = new CertifyActionsParcel(vKeySpinner.getSelectedKeyId()); + parcel.mCertifyActions.addAll(certifyActions); + + data.putParcelable(KeychainIntentService.CERTIFY_PARCEL, parcel); + /* if (mUploadKeyCheckbox.isChecked()) { + String keyserver = Preferences.getPreferences(getActivity()).getPreferredKeyserver(); + data.putString(KeychainIntentService.UPLOAD_KEY_SERVER, keyserver); + } */ + } + + // Send all information needed to service to sign key in other thread + Intent intent = new Intent(getActivity(), KeychainIntentService.class); + intent.setAction(KeychainIntentService.ACTION_CERTIFY_KEYRING); + intent.putExtra(KeychainIntentService.EXTRA_DATA, data); + + // Message is received after signing is done in KeychainIntentService + KeychainIntentServiceHandler saveHandler = new KeychainIntentServiceHandler(getActivity(), + getString(R.string.progress_certifying), ProgressDialog.STYLE_SPINNER, true) { + public void handleMessage(Message message) { + // handle messages by standard KeychainIntentServiceHandler first + super.handleMessage(message); + + if (message.arg1 == KeychainIntentServiceHandler.MESSAGE_OKAY) { + Bundle data = message.getData(); + CertifyResult result = data.getParcelable(CertifyResult.EXTRA_RESULT); + + Intent intent = new Intent(); + intent.putExtra(CertifyResult.EXTRA_RESULT, result); + getActivity().setResult(Activity.RESULT_OK, intent); + getActivity().finish(); + } + } + }; + + // Create a new Messenger for the communication back + Messenger messenger = new Messenger(saveHandler); + intent.putExtra(KeychainIntentService.EXTRA_MESSENGER, messenger); + + // show progress dialog + saveHandler.showProgressDialog(getActivity()); + + // start service with intent + getActivity().startService(intent); + + } + } -- cgit v1.2.3 From 99eb8725e92dde56511eafe2077e227cf9795f29 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Sun, 8 Mar 2015 04:42:19 +0100 Subject: successfully certify linked ids --- .../keychain/ui/linked/LinkedIdViewFragment.java | 73 ++++++++++++++++++---- 1 file changed, 62 insertions(+), 11 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index 7f8f4da04..6ad7fa443 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -1,6 +1,7 @@ package org.sufficientlysecure.keychain.ui.linked; import java.io.IOException; +import java.util.Arrays; import android.app.Activity; import android.app.ProgressDialog; @@ -22,9 +23,11 @@ import android.widget.TextView; import android.widget.ViewAnimator; import org.spongycastle.util.encoders.Hex; +import org.sufficientlysecure.keychain.Constants; import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.operations.results.CertifyResult; import org.sufficientlysecure.keychain.operations.results.LinkedVerifyResult; +import org.sufficientlysecure.keychain.pgp.WrappedUserAttribute; import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; import org.sufficientlysecure.keychain.pgp.linked.LinkedResource; @@ -34,21 +37,25 @@ import org.sufficientlysecure.keychain.service.CertifyActionsParcel; import org.sufficientlysecure.keychain.service.CertifyActionsParcel.CertifyAction; import org.sufficientlysecure.keychain.service.KeychainIntentService; import org.sufficientlysecure.keychain.service.KeychainIntentServiceHandler; +import org.sufficientlysecure.keychain.service.PassphraseCacheService; +import org.sufficientlysecure.keychain.ui.PassphraseDialogActivity; import org.sufficientlysecure.keychain.ui.adapter.LinkedIdsAdapter.ViewHolder; import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils; import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils.State; import org.sufficientlysecure.keychain.ui.util.Notify; import org.sufficientlysecure.keychain.ui.util.Notify.Style; import org.sufficientlysecure.keychain.ui.widget.CertifyKeySpinner; +import org.sufficientlysecure.keychain.util.Log; import org.sufficientlysecure.keychain.util.Preferences; public class LinkedIdViewFragment extends Fragment { + public static final int REQUEST_CODE_PASSPHRASE = 0x00008001; + private static final String ARG_ENCODED_LID = "encoded_lid"; private static final String ARG_VERIFIED = "verified"; private static final String ARG_FINGERPRINT = "fingerprint"; - private static final String ARG_MASTER_KEY_ID = "fingerprint"; private RawLinkedIdentity mLinkedId; private LinkedCookieResource mLinkedResource; @@ -195,7 +202,7 @@ public class LinkedIdViewFragment extends Fragment { button_confirm.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { - certifyResource(); + initiateCertifying(); } }); @@ -291,15 +298,62 @@ public class LinkedIdViewFragment extends Fragment { } - private void certifyResource() { + private void initiateCertifying() { + // get the user's passphrase for this key (if required) + String passphrase; + long certifyKeyId = vKeySpinner.getSelectedItemId(); + try { + passphrase = PassphraseCacheService.getCachedPassphrase( + getActivity(), certifyKeyId, certifyKeyId); + } catch (PassphraseCacheService.KeyNotFoundException e) { + Log.e(Constants.TAG, "Key not found!", e); + getActivity().finish(); + return; + } + if (passphrase == null) { + Intent intent = new Intent(getActivity(), PassphraseDialogActivity.class); + intent.putExtra(PassphraseDialogActivity.EXTRA_SUBKEY_ID, certifyKeyId); + startActivityForResult(intent, REQUEST_CODE_PASSPHRASE); + // bail out; need to wait until the user has entered the passphrase before trying again + } else { + certifyResource(certifyKeyId, ""); + } + } + + @Override + public void onActivityResult(int requestCode, int resultCode, Intent data) { + switch (requestCode) { + case REQUEST_CODE_PASSPHRASE: { + if (resultCode == Activity.RESULT_OK && data != null) { + String passphrase = data.getStringExtra( + PassphraseDialogActivity.MESSAGE_DATA_PASSPHRASE); + long certifyKeyId = data.getLongExtra(PassphraseDialogActivity.EXTRA_KEY_ID, 0L); + if (certifyKeyId == 0L) { + throw new AssertionError("key id must not be 0"); + } + certifyResource(certifyKeyId, passphrase); + } + return; + } + + default: { + super.onActivityResult(requestCode, resultCode, data); + } + } + } + + private void certifyResource(long certifyKeyId, String passphrase) { Bundle data = new Bundle(); { - CertifyAction action = new CertifyAction(); + + long masterKeyId = KeyFormattingUtils.convertFingerprintToKeyId(mFingerprint); + CertifyAction action = new CertifyAction(masterKeyId, null, + Arrays.asList(mLinkedId.toUserAttribute())); // fill values for this action - CertifyActionsParcel parcel = new CertifyActionsParcel(vKeySpinner.getSelectedKeyId()); - parcel.mCertifyActions.addAll(certifyActions); + CertifyActionsParcel parcel = new CertifyActionsParcel(certifyKeyId); + parcel.mCertifyActions.addAll(Arrays.asList(action)); data.putParcelable(KeychainIntentService.CERTIFY_PARCEL, parcel); /* if (mUploadKeyCheckbox.isChecked()) { @@ -315,7 +369,7 @@ public class LinkedIdViewFragment extends Fragment { // Message is received after signing is done in KeychainIntentService KeychainIntentServiceHandler saveHandler = new KeychainIntentServiceHandler(getActivity(), - getString(R.string.progress_certifying), ProgressDialog.STYLE_SPINNER, true) { + getString(R.string.progress_certifying), ProgressDialog.STYLE_SPINNER, false) { public void handleMessage(Message message) { // handle messages by standard KeychainIntentServiceHandler first super.handleMessage(message); @@ -324,10 +378,7 @@ public class LinkedIdViewFragment extends Fragment { Bundle data = message.getData(); CertifyResult result = data.getParcelable(CertifyResult.EXTRA_RESULT); - Intent intent = new Intent(); - intent.putExtra(CertifyResult.EXTRA_RESULT, result); - getActivity().setResult(Activity.RESULT_OK, intent); - getActivity().finish(); + result.createNotify(getActivity()).show(); } } }; -- cgit v1.2.3 From 08fd2a2de3795cf8fc4be590ba993c356c8eb67f Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Mon, 9 Mar 2015 16:30:13 +0100 Subject: use loader in LinkedIdViewFragment --- .../keychain/ui/linked/LinkedIdViewFragment.java | 262 ++++++++++++++------- 1 file changed, 174 insertions(+), 88 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index 6ad7fa443..fcb9d7bb4 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -7,12 +7,16 @@ import android.app.Activity; import android.app.ProgressDialog; import android.content.Context; import android.content.Intent; +import android.database.Cursor; +import android.net.Uri; import android.os.AsyncTask; import android.os.Bundle; import android.os.Message; import android.os.Messenger; import android.support.v4.app.Fragment; -import android.support.v7.widget.CardView; +import android.support.v4.app.LoaderManager; +import android.support.v4.content.CursorLoader; +import android.support.v4.content.Loader; import android.view.LayoutInflater; import android.view.View; import android.view.View.OnClickListener; @@ -22,151 +26,183 @@ import android.widget.LinearLayout; import android.widget.TextView; import android.widget.ViewAnimator; -import org.spongycastle.util.encoders.Hex; import org.sufficientlysecure.keychain.Constants; import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.operations.results.CertifyResult; import org.sufficientlysecure.keychain.operations.results.LinkedVerifyResult; -import org.sufficientlysecure.keychain.pgp.WrappedUserAttribute; import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; import org.sufficientlysecure.keychain.pgp.linked.LinkedResource; import org.sufficientlysecure.keychain.pgp.linked.RawLinkedIdentity; import org.sufficientlysecure.keychain.provider.KeychainContract.Certs; +import org.sufficientlysecure.keychain.provider.KeychainContract.UserPackets; +import org.sufficientlysecure.keychain.provider.KeychainDatabase.Tables; import org.sufficientlysecure.keychain.service.CertifyActionsParcel; import org.sufficientlysecure.keychain.service.CertifyActionsParcel.CertifyAction; import org.sufficientlysecure.keychain.service.KeychainIntentService; import org.sufficientlysecure.keychain.service.KeychainIntentServiceHandler; import org.sufficientlysecure.keychain.service.PassphraseCacheService; import org.sufficientlysecure.keychain.ui.PassphraseDialogActivity; -import org.sufficientlysecure.keychain.ui.adapter.LinkedIdsAdapter.ViewHolder; +import org.sufficientlysecure.keychain.ui.adapter.LinkedIdsAdapter; +import org.sufficientlysecure.keychain.ui.adapter.LinkedIdsCertAdapter; +import org.sufficientlysecure.keychain.ui.adapter.UserIdsAdapter; import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils; import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils.State; -import org.sufficientlysecure.keychain.ui.util.Notify; -import org.sufficientlysecure.keychain.ui.util.Notify.Style; import org.sufficientlysecure.keychain.ui.widget.CertifyKeySpinner; import org.sufficientlysecure.keychain.util.Log; -import org.sufficientlysecure.keychain.util.Preferences; -public class LinkedIdViewFragment extends Fragment { +public class LinkedIdViewFragment extends Fragment implements + LoaderManager.LoaderCallbacks { public static final int REQUEST_CODE_PASSPHRASE = 0x00008001; - private static final String ARG_ENCODED_LID = "encoded_lid"; - private static final String ARG_VERIFIED = "verified"; + private static final String ARG_DATA_URI = "data_uri"; + private static final String ARG_LID_RANK = "rank"; + private static final String ARG_SHOWCERT = "verified"; private static final String ARG_FINGERPRINT = "fingerprint"; + private static final int LOADER_ID_LINKED_CERTS = 1; + private static final int LOADER_ID_LINKED_ID = 2; private RawLinkedIdentity mLinkedId; private LinkedCookieResource mLinkedResource; - private Integer mVerified; + private boolean mShowCert; - private CardView vLinkedIdsCard; private Context mContext; private byte[] mFingerprint; private LayoutInflater mInflater; - private LinearLayout vLinkedCerts; - private View mCurrentCert; private boolean mInProgress; - private ViewAnimator mButtonSwitcher; - private CertifyKeySpinner vKeySpinner; + + private LinkedIdsCertAdapter mCertAdapter; + private Uri mDataUri; + private ViewHolder mViewHolder; + private View mCurrentCert; + private int mLidRank; + + public static Fragment newInstance(Uri dataUri, int rank, + boolean showCertified, byte[] fingerprint) throws IOException { + LinkedIdViewFragment frag = new LinkedIdViewFragment(); + + Bundle args = new Bundle(); + args.putParcelable(ARG_DATA_URI, dataUri); + args.putInt(ARG_LID_RANK, rank); + args.putBoolean(ARG_SHOWCERT, showCertified); + args.putByteArray(ARG_FINGERPRINT, fingerprint); + frag.setArguments(args); + + return frag; + } @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Bundle args = getArguments(); - byte[] data = args.getByteArray(ARG_ENCODED_LID); - - try { - mLinkedId = LinkedIdentity.fromAttributeData(data); - } catch (IOException e) { - // TODO um… - e.printStackTrace(); - throw new AssertionError("reconstruction of user attribute must succeed!"); - } - - if (mLinkedId instanceof LinkedIdentity) { - LinkedResource res = ((LinkedIdentity) mLinkedId).mResource; - mLinkedResource = (LinkedCookieResource) res; - } + mDataUri = args.getParcelable(ARG_DATA_URI); + mLidRank = args.getInt(ARG_LID_RANK); - mVerified = args.containsKey(ARG_VERIFIED) ? args.getInt(ARG_VERIFIED) : null; + mShowCert = args.getBoolean(ARG_SHOWCERT); mFingerprint = args.getByteArray(ARG_FINGERPRINT); mContext = getActivity(); mInflater = getLayoutInflater(savedInstanceState); - } - - public static Fragment newInstance(RawLinkedIdentity id, - Integer isVerified, byte[] fingerprint) throws IOException { - LinkedIdViewFragment frag = new LinkedIdViewFragment(); + mCertAdapter = new LinkedIdsCertAdapter(getActivity(), null, 0); + // getLoaderManager().initLoader(LOADER_ID_LINKED_CERTS, null, this); + getLoaderManager().initLoader(LOADER_ID_LINKED_ID, null, this); - Bundle args = new Bundle(); - args.putByteArray(ARG_ENCODED_LID, id.toUserAttribute().getEncoded()); - if (isVerified != null) { - args.putInt(ARG_VERIFIED, isVerified); + } + @Override + public Loader onCreateLoader(int id, Bundle args) { + switch (id) { + case LOADER_ID_LINKED_ID: + return new CursorLoader(getActivity(), mDataUri, + UserIdsAdapter.USER_PACKETS_PROJECTION, + Tables.USER_PACKETS + "." + UserPackets.RANK + + " = " + Integer.toString(mLidRank), null, null); + + case LOADER_ID_LINKED_CERTS: + return LinkedIdsCertAdapter.createLoader(getActivity(), mDataUri); + + default: + return null; } - args.putByteArray(ARG_FINGERPRINT, fingerprint); - frag.setArguments(args); - - return frag; } @Override - public View onCreateView(LayoutInflater inflater, ViewGroup superContainer, Bundle savedInstanceState) { - View root = inflater.inflate(R.layout.linked_id_view_fragment, null); + public void onLoadFinished(Loader loader, Cursor cursor) { + switch (loader.getId()) { + case LOADER_ID_LINKED_ID: - vLinkedIdsCard = (CardView) root.findViewById(R.id.card_linked_ids); - vLinkedCerts = (LinearLayout) root.findViewById(R.id.linked_id_certs); - vKeySpinner = (CertifyKeySpinner) root.findViewById(R.id.cert_key_spinner); + // TODO proper error reporting and null checks here! - View back = root.findViewById(R.id.back_button); - back.setClickable(true); - back.findViewById(R.id.back_button).setOnClickListener(new OnClickListener() { - @Override - public void onClick(View v) { - getFragmentManager().popBackStack(); - } - }); + if (!cursor.moveToFirst()) { + Log.e(Constants.TAG, "error"); + break; + } - ViewHolder holder = new ViewHolder(root); + try { + int certStatus = cursor.getInt(UserIdsAdapter.INDEX_VERIFIED); - if (mVerified != null) { - holder.vVerified.setVisibility(View.VISIBLE); - switch (mVerified) { + byte[] data = cursor.getBlob(UserIdsAdapter.INDEX_ATTRIBUTE_DATA); + RawLinkedIdentity linkedId = LinkedIdentity.fromAttributeData(data); + + loadIdentity(linkedId, certStatus); + } catch (IOException e) { + e.printStackTrace(); + throw new AssertionError("reconstruction of user attribute must succeed!"); + } + + break; + + case LOADER_ID_LINKED_CERTS: + mCertAdapter.swapCursor(cursor); + break; + } + } + + private void loadIdentity(RawLinkedIdentity linkedId, int certStatus) { + mLinkedId = linkedId; + + if (mLinkedId instanceof LinkedIdentity) { + LinkedResource res = ((LinkedIdentity) mLinkedId).mResource; + mLinkedResource = (LinkedCookieResource) res; + } + + if (mShowCert) { + mViewHolder.mLinkedIdHolder.vVerified.setVisibility(View.VISIBLE); + + switch (certStatus) { case Certs.VERIFIED_SECRET: - KeyFormattingUtils.setStatusImage(mContext, holder.vVerified, + KeyFormattingUtils.setStatusImage(mContext, mViewHolder.mLinkedIdHolder.vVerified, null, State.VERIFIED, KeyFormattingUtils.DEFAULT_COLOR); break; case Certs.VERIFIED_SELF: - KeyFormattingUtils.setStatusImage(mContext, holder.vVerified, + KeyFormattingUtils.setStatusImage(mContext, mViewHolder.mLinkedIdHolder.vVerified, null, State.UNVERIFIED, KeyFormattingUtils.DEFAULT_COLOR); break; default: - KeyFormattingUtils.setStatusImage(mContext, holder.vVerified, + KeyFormattingUtils.setStatusImage(mContext, mViewHolder.mLinkedIdHolder.vVerified, null, State.INVALID, KeyFormattingUtils.DEFAULT_COLOR); break; } } else { - holder.vVerified.setVisibility(View.GONE); + mViewHolder.mLinkedIdHolder.vVerified.setVisibility(View.GONE); } - holder.setData(mContext, mLinkedId); + mViewHolder.mLinkedIdHolder.setData(mContext, mLinkedId); // no resource, nothing further we can do… if (mLinkedResource == null) { - root.findViewById(R.id.button_view).setVisibility(View.GONE); - root.findViewById(R.id.button_verify).setVisibility(View.GONE); - return root; + mViewHolder.vButtonView.setVisibility(View.GONE); + mViewHolder.vButtonVerify.setVisibility(View.GONE); + return; } - View button_view = root.findViewById(R.id.button_view); if (mLinkedResource.isViewable()) { - button_view.setVisibility(View.VISIBLE); - button_view.setOnClickListener(new OnClickListener() { + mViewHolder.vButtonView.setVisibility(View.VISIBLE); + mViewHolder.vButtonView.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { Intent intent = mLinkedResource.getViewIntent(); @@ -177,29 +213,79 @@ public class LinkedIdViewFragment extends Fragment { } }); } else { - button_view.setVisibility(View.GONE); + mViewHolder.vButtonView.setVisibility(View.GONE); + } + + } + + @Override + public void onLoaderReset(Loader loader) { + switch (loader.getId()) { + case LOADER_ID_LINKED_CERTS: + mCertAdapter.swapCursor(null); + break; + } + + } + + static class ViewHolder { + private final View vButtonView; + LinkedIdsAdapter.ViewHolder mLinkedIdHolder; + + private ViewAnimator mButtonSwitcher; + private LinearLayout vLinkedCerts; + private CertifyKeySpinner vKeySpinner; + private LinearLayout vLinkedVerify; + private final View vButtonVerify; + private final View vButtonRetry; + private final View vButtonConfirm; + private final View vButtonBack; + + ViewHolder(View root) { + vLinkedCerts = (LinearLayout) root.findViewById(R.id.linked_id_certs); + vLinkedVerify = (LinearLayout) root.findViewById(R.id.linked_id_verify); + vKeySpinner = (CertifyKeySpinner) root.findViewById(R.id.cert_key_spinner); + mButtonSwitcher = (ViewAnimator) root.findViewById(R.id.button_animator); + + mLinkedIdHolder = new LinkedIdsAdapter.ViewHolder(root); + + vButtonBack = root.findViewById(R.id.back_button); + vButtonVerify = root.findViewById(R.id.button_verify); + vButtonRetry = root.findViewById(R.id.button_retry); + vButtonConfirm = root.findViewById(R.id.button_confirm); + vButtonView = root.findViewById(R.id.button_view); } - mButtonSwitcher = (ViewAnimator) root.findViewById(R.id.button_animator); + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup superContainer, Bundle savedInstanceState) { + View root = inflater.inflate(R.layout.linked_id_view_fragment, null); - View button_verify = root.findViewById(R.id.button_verify); - button_verify.setOnClickListener(new OnClickListener() { + mViewHolder = new ViewHolder(root); + root.setTag(mViewHolder); + + mViewHolder.vButtonBack.setClickable(true); + mViewHolder.vButtonBack.findViewById(R.id.back_button).setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { - verifyResource(); + getFragmentManager().popBackStack(); } }); - View button_retry = root.findViewById(R.id.button_retry); - button_retry.setOnClickListener(new OnClickListener() { + mViewHolder.vButtonVerify.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { verifyResource(); } }); - - View button_confirm = root.findViewById(R.id.button_confirm); - button_confirm.setOnClickListener(new OnClickListener() { + mViewHolder.vButtonRetry.setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + verifyResource(); + } + }); + mViewHolder.vButtonConfirm.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { initiateCertifying(); @@ -225,10 +311,10 @@ public class LinkedIdViewFragment extends Fragment { } void showButton(int which) { - if (mButtonSwitcher.getDisplayedChild() == which) { + if (mViewHolder.mButtonSwitcher.getDisplayedChild() == which) { return; } - mButtonSwitcher.setDisplayedChild(which); + mViewHolder.mButtonSwitcher.setDisplayedChild(which); } void verifyResource() { @@ -247,12 +333,12 @@ public class LinkedIdViewFragment extends Fragment { mCurrentCert = mInflater.inflate(R.layout.linked_id_cert, null); holder = new ViewHolderCert(mCurrentCert); mCurrentCert.setTag(holder); - vLinkedCerts.addView(mCurrentCert); + mViewHolder.vLinkedVerify.addView(mCurrentCert); } else { holder = (ViewHolderCert) mCurrentCert.getTag(); } - vKeySpinner.setVisibility(View.GONE); + mViewHolder.vKeySpinner.setVisibility(View.GONE); holder.setShowProgress(true); holder.vText.setText("Verifying…"); @@ -294,14 +380,14 @@ public class LinkedIdViewFragment extends Fragment { // button is 'confirm' showButton(2); - vKeySpinner.setVisibility(View.VISIBLE); + mViewHolder.vKeySpinner.setVisibility(View.VISIBLE); } private void initiateCertifying() { // get the user's passphrase for this key (if required) String passphrase; - long certifyKeyId = vKeySpinner.getSelectedItemId(); + long certifyKeyId = mViewHolder.vKeySpinner.getSelectedItemId(); try { passphrase = PassphraseCacheService.getCachedPassphrase( getActivity(), certifyKeyId, certifyKeyId); -- cgit v1.2.3 From 138773798ae9325ba92021c8779f71e6fc0c23c6 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Mon, 9 Mar 2015 16:56:10 +0100 Subject: fix transition animation --- .../keychain/ui/linked/LinkedIdViewFragment.java | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index fcb9d7bb4..284e6e0c1 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -79,8 +79,9 @@ public class LinkedIdViewFragment extends Fragment implements private ViewHolder mViewHolder; private View mCurrentCert; private int mLidRank; + private OnIdentityLoadedListener mIdLoadedListener; - public static Fragment newInstance(Uri dataUri, int rank, + public static LinkedIdViewFragment newInstance(Uri dataUri, int rank, boolean showCertified, byte[] fingerprint) throws IOException { LinkedIdViewFragment frag = new LinkedIdViewFragment(); @@ -149,6 +150,12 @@ public class LinkedIdViewFragment extends Fragment implements RawLinkedIdentity linkedId = LinkedIdentity.fromAttributeData(data); loadIdentity(linkedId, certStatus); + + if (mIdLoadedListener != null) { + mIdLoadedListener.onIdentityLoaded(); + mIdLoadedListener = null; + } + } catch (IOException e) { e.printStackTrace(); throw new AssertionError("reconstruction of user attribute must succeed!"); @@ -162,6 +169,14 @@ public class LinkedIdViewFragment extends Fragment implements } } + public interface OnIdentityLoadedListener { + public void onIdentityLoaded(); + } + + public void setOnIdentityLoadedListener(OnIdentityLoadedListener listener) { + mIdLoadedListener = listener; + } + private void loadIdentity(RawLinkedIdentity linkedId, int certStatus) { mLinkedId = linkedId; -- cgit v1.2.3 From ebf359634139ff2125233a78a976388082abf00c Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Mon, 9 Mar 2015 21:04:03 +0100 Subject: rearrange linked id layouts, add CertListWidget --- .../keychain/ui/linked/LinkedIdViewFragment.java | 102 ++++++++++----------- 1 file changed, 46 insertions(+), 56 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index 284e6e0c1..5b8d14c4c 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -22,7 +22,6 @@ import android.view.View; import android.view.View.OnClickListener; import android.view.ViewGroup; import android.widget.ImageView; -import android.widget.LinearLayout; import android.widget.TextView; import android.widget.ViewAnimator; @@ -44,10 +43,10 @@ import org.sufficientlysecure.keychain.service.KeychainIntentServiceHandler; import org.sufficientlysecure.keychain.service.PassphraseCacheService; import org.sufficientlysecure.keychain.ui.PassphraseDialogActivity; import org.sufficientlysecure.keychain.ui.adapter.LinkedIdsAdapter; -import org.sufficientlysecure.keychain.ui.adapter.LinkedIdsCertAdapter; import org.sufficientlysecure.keychain.ui.adapter.UserIdsAdapter; import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils; import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils.State; +import org.sufficientlysecure.keychain.ui.widget.CertListWidget; import org.sufficientlysecure.keychain.ui.widget.CertifyKeySpinner; import org.sufficientlysecure.keychain.util.Log; @@ -61,8 +60,7 @@ public class LinkedIdViewFragment extends Fragment implements private static final String ARG_LID_RANK = "rank"; private static final String ARG_SHOWCERT = "verified"; private static final String ARG_FINGERPRINT = "fingerprint"; - private static final int LOADER_ID_LINKED_CERTS = 1; - private static final int LOADER_ID_LINKED_ID = 2; + private static final int LOADER_ID_LINKED_ID = 1; private RawLinkedIdentity mLinkedId; private LinkedCookieResource mLinkedResource; @@ -74,10 +72,8 @@ public class LinkedIdViewFragment extends Fragment implements private boolean mInProgress; - private LinkedIdsCertAdapter mCertAdapter; private Uri mDataUri; private ViewHolder mViewHolder; - private View mCurrentCert; private int mLidRank; private OnIdentityLoadedListener mIdLoadedListener; @@ -109,11 +105,9 @@ public class LinkedIdViewFragment extends Fragment implements mContext = getActivity(); mInflater = getLayoutInflater(savedInstanceState); - mCertAdapter = new LinkedIdsCertAdapter(getActivity(), null, 0); - // getLoaderManager().initLoader(LOADER_ID_LINKED_CERTS, null, this); getLoaderManager().initLoader(LOADER_ID_LINKED_ID, null, this); - } + @Override public Loader onCreateLoader(int id, Bundle args) { switch (id) { @@ -122,10 +116,6 @@ public class LinkedIdViewFragment extends Fragment implements UserIdsAdapter.USER_PACKETS_PROJECTION, Tables.USER_PACKETS + "." + UserPackets.RANK + " = " + Integer.toString(mLidRank), null, null); - - case LOADER_ID_LINKED_CERTS: - return LinkedIdsCertAdapter.createLoader(getActivity(), mDataUri); - default: return null; } @@ -162,10 +152,6 @@ public class LinkedIdViewFragment extends Fragment implements } break; - - case LOADER_ID_LINKED_CERTS: - mCertAdapter.swapCursor(cursor); - break; } } @@ -180,6 +166,16 @@ public class LinkedIdViewFragment extends Fragment implements private void loadIdentity(RawLinkedIdentity linkedId, int certStatus) { mLinkedId = linkedId; + mViewHolder.setShowVerifying(false); + + { + Bundle args = new Bundle(); + args.putParcelable(CertListWidget.ARG_URI, mDataUri); + args.putInt(CertListWidget.ARG_RANK, mLidRank); + getLoaderManager().initLoader(CertListWidget.LOADER_ID_LINKED_CERTS, + args, mViewHolder.vLinkedCerts); + } + if (mLinkedId instanceof LinkedIdentity) { LinkedResource res = ((LinkedIdentity) mLinkedId).mResource; mLinkedResource = (LinkedCookieResource) res; @@ -235,30 +231,28 @@ public class LinkedIdViewFragment extends Fragment implements @Override public void onLoaderReset(Loader loader) { - switch (loader.getId()) { - case LOADER_ID_LINKED_CERTS: - mCertAdapter.swapCursor(null); - break; - } } static class ViewHolder { private final View vButtonView; + private final ViewAnimator vVerifyingContainer; LinkedIdsAdapter.ViewHolder mLinkedIdHolder; private ViewAnimator mButtonSwitcher; - private LinearLayout vLinkedCerts; + private CertListWidget vLinkedCerts; private CertifyKeySpinner vKeySpinner; - private LinearLayout vLinkedVerify; private final View vButtonVerify; private final View vButtonRetry; private final View vButtonConfirm; private final View vButtonBack; + private final ViewAnimator vProgress; + private final ImageView vIcon; + private final TextView vText; + ViewHolder(View root) { - vLinkedCerts = (LinearLayout) root.findViewById(R.id.linked_id_certs); - vLinkedVerify = (LinearLayout) root.findViewById(R.id.linked_id_verify); + vLinkedCerts = (CertListWidget) root.findViewById(R.id.linked_id_certs); vKeySpinner = (CertifyKeySpinner) root.findViewById(R.id.cert_key_spinner); mButtonSwitcher = (ViewAnimator) root.findViewById(R.id.button_animator); @@ -269,6 +263,26 @@ public class LinkedIdViewFragment extends Fragment implements vButtonRetry = root.findViewById(R.id.button_retry); vButtonConfirm = root.findViewById(R.id.button_confirm); vButtonView = root.findViewById(R.id.button_view); + + vVerifyingContainer = (ViewAnimator) root.findViewById(R.id.linked_verify_container); + + vProgress = (ViewAnimator) root.findViewById(R.id.linked_cert_progress); + vIcon = (ImageView) root.findViewById(R.id.linked_cert_icon); + vText = (TextView) root.findViewById(R.id.linked_cert_text); + } + + void setShowVerifying(boolean show) { + int child = show ? 1 : 0; + if (vVerifyingContainer.getDisplayedChild() != child) { + vVerifyingContainer.setDisplayedChild(child); + } + if (!show) { + vKeySpinner.setVisibility(View.GONE); + } + } + + void setShowProgress(boolean show) { + vProgress.setDisplayedChild(show ? 0 : 1); } } @@ -310,21 +324,6 @@ public class LinkedIdViewFragment extends Fragment implements return root; } - static class ViewHolderCert { - final ViewAnimator vProgress; - final ImageView vIcon; - final TextView vText; - - ViewHolderCert(View view) { - vProgress = (ViewAnimator) view.findViewById(R.id.linked_cert_progress); - vIcon = (ImageView) view.findViewById(R.id.linked_cert_icon); - vText = (TextView) view.findViewById(R.id.linked_cert_text); - } - void setShowProgress(boolean show) { - vProgress.setDisplayedChild(show ? 0 : 1); - } - } - void showButton(int which) { if (mViewHolder.mButtonSwitcher.getDisplayedChild() == which) { return; @@ -342,20 +341,11 @@ public class LinkedIdViewFragment extends Fragment implements mInProgress = true; } - // is there a current certification? if not create a new one - final ViewHolderCert holder; - if (mCurrentCert == null) { - mCurrentCert = mInflater.inflate(R.layout.linked_id_cert, null); - holder = new ViewHolderCert(mCurrentCert); - mCurrentCert.setTag(holder); - mViewHolder.vLinkedVerify.addView(mCurrentCert); - } else { - holder = (ViewHolderCert) mCurrentCert.getTag(); - } + mViewHolder.setShowVerifying(true); mViewHolder.vKeySpinner.setVisibility(View.GONE); - holder.setShowProgress(true); - holder.vText.setText("Verifying…"); + mViewHolder.setShowProgress(true); + mViewHolder.vText.setText("Verifying…"); new AsyncTask() { @Override @@ -376,13 +366,13 @@ public class LinkedIdViewFragment extends Fragment implements @Override protected void onPostExecute(LinkedVerifyResult result) { - holder.setShowProgress(false); + mViewHolder.setShowProgress(false); if (result.success()) { - holder.vText.setText("Ok"); + mViewHolder.vText.setText("Ok"); setupForConfirmation(); } else { showButton(1); - holder.vText.setText("Error"); + mViewHolder.vText.setText("Error"); } mInProgress = false; } -- cgit v1.2.3 From 6df9387c2c08c7e872e4721c5d677188d29164f4 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Mon, 9 Mar 2015 23:58:05 +0100 Subject: support backstack for verification --- .../keychain/ui/linked/LinkedIdViewFragment.java | 38 +++++++++++++++------- 1 file changed, 26 insertions(+), 12 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index 5b8d14c4c..8e81eb383 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -14,6 +14,8 @@ import android.os.Bundle; import android.os.Message; import android.os.Messenger; import android.support.v4.app.Fragment; +import android.support.v4.app.FragmentManager; +import android.support.v4.app.FragmentManager.OnBackStackChangedListener; import android.support.v4.app.LoaderManager; import android.support.v4.content.CursorLoader; import android.support.v4.content.Loader; @@ -52,7 +54,7 @@ import org.sufficientlysecure.keychain.util.Log; public class LinkedIdViewFragment extends Fragment implements - LoaderManager.LoaderCallbacks { + LoaderManager.LoaderCallbacks, OnBackStackChangedListener { public static final int REQUEST_CODE_PASSPHRASE = 0x00008001; @@ -155,6 +157,12 @@ public class LinkedIdViewFragment extends Fragment implements } } + @Override + public void onBackStackChanged() { + mViewHolder.setShowVerifying(false); + getFragmentManager().removeOnBackStackChangedListener(LinkedIdViewFragment.this); + } + public interface OnIdentityLoadedListener { public void onIdentityLoaded(); } @@ -239,7 +247,7 @@ public class LinkedIdViewFragment extends Fragment implements private final ViewAnimator vVerifyingContainer; LinkedIdsAdapter.ViewHolder mLinkedIdHolder; - private ViewAnimator mButtonSwitcher; + private ViewAnimator vButtonSwitcher; private CertListWidget vLinkedCerts; private CertifyKeySpinner vKeySpinner; private final View vButtonVerify; @@ -254,7 +262,7 @@ public class LinkedIdViewFragment extends Fragment implements ViewHolder(View root) { vLinkedCerts = (CertListWidget) root.findViewById(R.id.linked_id_certs); vKeySpinner = (CertifyKeySpinner) root.findViewById(R.id.cert_key_spinner); - mButtonSwitcher = (ViewAnimator) root.findViewById(R.id.button_animator); + vButtonSwitcher = (ViewAnimator) root.findViewById(R.id.button_animator); mLinkedIdHolder = new LinkedIdsAdapter.ViewHolder(root); @@ -278,6 +286,7 @@ public class LinkedIdViewFragment extends Fragment implements } if (!show) { vKeySpinner.setVisibility(View.GONE); + showButton(0); } } @@ -285,6 +294,13 @@ public class LinkedIdViewFragment extends Fragment implements vProgress.setDisplayedChild(show ? 0 : 1); } + void showButton(int which) { + if (vButtonSwitcher.getDisplayedChild() == which) { + return; + } + vButtonSwitcher.setDisplayedChild(which); + } + } @Override @@ -324,13 +340,6 @@ public class LinkedIdViewFragment extends Fragment implements return root; } - void showButton(int which) { - if (mViewHolder.mButtonSwitcher.getDisplayedChild() == which) { - return; - } - mViewHolder.mButtonSwitcher.setDisplayedChild(which); - } - void verifyResource() { // only one at a time @@ -341,6 +350,11 @@ public class LinkedIdViewFragment extends Fragment implements mInProgress = true; } + FragmentManager manager = getFragmentManager(); + manager.beginTransaction().addToBackStack("verification").commit(); + manager.executePendingTransactions(); + manager.addOnBackStackChangedListener(this); + mViewHolder.setShowVerifying(true); mViewHolder.vKeySpinner.setVisibility(View.GONE); @@ -371,7 +385,7 @@ public class LinkedIdViewFragment extends Fragment implements mViewHolder.vText.setText("Ok"); setupForConfirmation(); } else { - showButton(1); + mViewHolder.showButton(1); mViewHolder.vText.setText("Error"); } mInProgress = false; @@ -383,7 +397,7 @@ public class LinkedIdViewFragment extends Fragment implements void setupForConfirmation() { // button is 'confirm' - showButton(2); + mViewHolder.showButton(2); mViewHolder.vKeySpinner.setVisibility(View.VISIBLE); -- cgit v1.2.3 From f76f84dfb2e406dd613be04dabd9432ffd0f9c4b Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Tue, 10 Mar 2015 00:55:48 +0100 Subject: concurrency and continuity fixes for verification backstack handling --- .../keychain/ui/linked/LinkedIdViewFragment.java | 40 ++++++++++++++-------- 1 file changed, 26 insertions(+), 14 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index 8e81eb383..f523441c5 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -11,6 +11,7 @@ import android.database.Cursor; import android.net.Uri; import android.os.AsyncTask; import android.os.Bundle; +import android.os.Handler; import android.os.Message; import android.os.Messenger; import android.support.v4.app.Fragment; @@ -72,7 +73,7 @@ public class LinkedIdViewFragment extends Fragment implements private byte[] mFingerprint; private LayoutInflater mInflater; - private boolean mInProgress; + private AsyncTask mInProgress; private Uri mDataUri; private ViewHolder mViewHolder; @@ -157,12 +158,6 @@ public class LinkedIdViewFragment extends Fragment implements } } - @Override - public void onBackStackChanged() { - mViewHolder.setShowVerifying(false); - getFragmentManager().removeOnBackStackChangedListener(LinkedIdViewFragment.this); - } - public interface OnIdentityLoadedListener { public void onIdentityLoaded(); } @@ -174,6 +169,13 @@ public class LinkedIdViewFragment extends Fragment implements private void loadIdentity(RawLinkedIdentity linkedId, int certStatus) { mLinkedId = linkedId; + new Handler().post(new Runnable() { + @Override + public void run() { + getFragmentManager().popBackStack("verification", + FragmentManager.POP_BACK_STACK_INCLUSIVE); + } + }); mViewHolder.setShowVerifying(false); { @@ -343,11 +345,8 @@ public class LinkedIdViewFragment extends Fragment implements void verifyResource() { // only one at a time - synchronized (this) { - if (mInProgress) { - return; - } - mInProgress = true; + if (mInProgress != null) { + return; } FragmentManager manager = getFragmentManager(); @@ -361,7 +360,7 @@ public class LinkedIdViewFragment extends Fragment implements mViewHolder.setShowProgress(true); mViewHolder.vText.setText("Verifying…"); - new AsyncTask() { + mInProgress = new AsyncTask() { @Override protected LinkedVerifyResult doInBackground(Void... params) { long timer = System.currentTimeMillis(); @@ -381,6 +380,9 @@ public class LinkedIdViewFragment extends Fragment implements @Override protected void onPostExecute(LinkedVerifyResult result) { mViewHolder.setShowProgress(false); + if (isCancelled()) { + return; + } if (result.success()) { mViewHolder.vText.setText("Ok"); setupForConfirmation(); @@ -388,7 +390,7 @@ public class LinkedIdViewFragment extends Fragment implements mViewHolder.showButton(1); mViewHolder.vText.setText("Error"); } - mInProgress = false; + mInProgress = null; } }.execute(); @@ -425,6 +427,16 @@ public class LinkedIdViewFragment extends Fragment implements } } + @Override + public void onBackStackChanged() { + mViewHolder.setShowVerifying(false); + getFragmentManager().removeOnBackStackChangedListener(LinkedIdViewFragment.this); + if (mInProgress != null) { + mInProgress.cancel(false); + mInProgress = null; + } + } + @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { switch (requestCode) { -- cgit v1.2.3 From 2a42ff016fbe3974811323f4da3775279d6bdccc Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Tue, 10 Mar 2015 02:08:51 +0100 Subject: cleaner handling of verification state --- .../keychain/ui/linked/LinkedIdViewFragment.java | 110 ++++++++++++--------- 1 file changed, 64 insertions(+), 46 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index f523441c5..1c301c642 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -71,7 +71,6 @@ public class LinkedIdViewFragment extends Fragment implements private Context mContext; private byte[] mFingerprint; - private LayoutInflater mInflater; private AsyncTask mInProgress; @@ -106,9 +105,9 @@ public class LinkedIdViewFragment extends Fragment implements mFingerprint = args.getByteArray(ARG_FINGERPRINT); mContext = getActivity(); - mInflater = getLayoutInflater(savedInstanceState); getLoaderManager().initLoader(LOADER_ID_LINKED_ID, null, this); + } @Override @@ -169,22 +168,7 @@ public class LinkedIdViewFragment extends Fragment implements private void loadIdentity(RawLinkedIdentity linkedId, int certStatus) { mLinkedId = linkedId; - new Handler().post(new Runnable() { - @Override - public void run() { - getFragmentManager().popBackStack("verification", - FragmentManager.POP_BACK_STACK_INCLUSIVE); - } - }); - mViewHolder.setShowVerifying(false); - - { - Bundle args = new Bundle(); - args.putParcelable(CertListWidget.ARG_URI, mDataUri); - args.putInt(CertListWidget.ARG_RANK, mLidRank); - getLoaderManager().initLoader(CertListWidget.LOADER_ID_LINKED_CERTS, - args, mViewHolder.vLinkedCerts); - } + setShowVerifying(false); if (mLinkedId instanceof LinkedIdentity) { LinkedResource res = ((LinkedIdentity) mLinkedId).mResource; @@ -281,17 +265,6 @@ public class LinkedIdViewFragment extends Fragment implements vText = (TextView) root.findViewById(R.id.linked_cert_text); } - void setShowVerifying(boolean show) { - int child = show ? 1 : 0; - if (vVerifyingContainer.getDisplayedChild() != child) { - vVerifyingContainer.setDisplayedChild(child); - } - if (!show) { - vKeySpinner.setVisibility(View.GONE); - showButton(0); - } - } - void setShowProgress(boolean show) { vProgress.setDisplayedChild(show ? 0 : 1); } @@ -305,6 +278,58 @@ public class LinkedIdViewFragment extends Fragment implements } + private boolean mVerificationState = false; + /** Switches between the 'verifying' ui bit and certificate status. This method + * must behave correctly in all states, showing or hiding the appropriate views + * and cancelling pending operations where necessary. + * + * This method also handles back button functionality in combination with + * onBackStateChanged. + */ + void setShowVerifying(boolean show) { + if (!show) { + if (mInProgress != null) { + mInProgress.cancel(false); + mInProgress = null; + } + getFragmentManager().removeOnBackStackChangedListener(this); + new Handler().post(new Runnable() { + @Override + public void run() { + getFragmentManager().popBackStack("verification", + FragmentManager.POP_BACK_STACK_INCLUSIVE); + } + }); + + if (!mVerificationState) { + return; + } + mVerificationState = false; + + mViewHolder.showButton(0); + mViewHolder.vKeySpinner.setVisibility(View.GONE); + mViewHolder.vVerifyingContainer.setDisplayedChild(0); + return; + } + + if (mVerificationState) { + return; + } + mVerificationState = true; + + FragmentManager manager = getFragmentManager(); + manager.beginTransaction().addToBackStack("verification").commit(); + manager.executePendingTransactions(); + manager.addOnBackStackChangedListener(this); + mViewHolder.vVerifyingContainer.setDisplayedChild(1); + + } + + @Override + public void onBackStackChanged() { + setShowVerifying(false); + } + @Override public View onCreateView(LayoutInflater inflater, ViewGroup superContainer, Bundle savedInstanceState) { View root = inflater.inflate(R.layout.linked_id_view_fragment, null); @@ -339,22 +364,25 @@ public class LinkedIdViewFragment extends Fragment implements } }); + { + Bundle args = new Bundle(); + args.putParcelable(CertListWidget.ARG_URI, mDataUri); + args.putInt(CertListWidget.ARG_RANK, mLidRank); + getLoaderManager().initLoader(CertListWidget.LOADER_ID_LINKED_CERTS, + args, mViewHolder.vLinkedCerts); + } + return root; } void verifyResource() { - // only one at a time + // only one at a time (no sync needed, mInProgress is only touched in ui thread) if (mInProgress != null) { return; } - FragmentManager manager = getFragmentManager(); - manager.beginTransaction().addToBackStack("verification").commit(); - manager.executePendingTransactions(); - manager.addOnBackStackChangedListener(this); - - mViewHolder.setShowVerifying(true); + setShowVerifying(true); mViewHolder.vKeySpinner.setVisibility(View.GONE); mViewHolder.setShowProgress(true); @@ -427,16 +455,6 @@ public class LinkedIdViewFragment extends Fragment implements } } - @Override - public void onBackStackChanged() { - mViewHolder.setShowVerifying(false); - getFragmentManager().removeOnBackStackChangedListener(LinkedIdViewFragment.this); - if (mInProgress != null) { - mInProgress.cancel(false); - mInProgress = null; - } - } - @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { switch (requestCode) { -- cgit v1.2.3 From f069d9814dd5bb4dcc99be1a08da2d7bcf350cde Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Tue, 10 Mar 2015 02:22:47 +0100 Subject: minor additions to CertListWidget --- .../sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index 1c301c642..21c9abca3 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -366,8 +366,7 @@ public class LinkedIdViewFragment extends Fragment implements { Bundle args = new Bundle(); - args.putParcelable(CertListWidget.ARG_URI, mDataUri); - args.putInt(CertListWidget.ARG_RANK, mLidRank); + args.putParcelable(CertListWidget.ARG_URI, Certs.buildLinkedIdCertsUri(mDataUri, mLidRank)); getLoaderManager().initLoader(CertListWidget.LOADER_ID_LINKED_CERTS, args, mViewHolder.vLinkedCerts); } -- cgit v1.2.3 From 8d71a3fa92c9a9b690c547cbb970b2a5924c10d6 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Tue, 10 Mar 2015 19:02:51 +0100 Subject: better state management in LinkedIdView, move confirm progress into card --- .../keychain/ui/linked/LinkedIdViewFragment.java | 77 ++++++++++++++-------- 1 file changed, 50 insertions(+), 27 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index 21c9abca3..742459ff8 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -47,6 +47,7 @@ import org.sufficientlysecure.keychain.service.PassphraseCacheService; import org.sufficientlysecure.keychain.ui.PassphraseDialogActivity; import org.sufficientlysecure.keychain.ui.adapter.LinkedIdsAdapter; import org.sufficientlysecure.keychain.ui.adapter.UserIdsAdapter; +import org.sufficientlysecure.keychain.ui.linked.LinkedIdViewFragment.ViewHolder.VerifyState; import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils; import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils.State; import org.sufficientlysecure.keychain.ui.widget.CertListWidget; @@ -242,7 +243,6 @@ public class LinkedIdViewFragment extends Fragment implements private final View vButtonBack; private final ViewAnimator vProgress; - private final ImageView vIcon; private final TextView vText; ViewHolder(View root) { @@ -261,12 +261,41 @@ public class LinkedIdViewFragment extends Fragment implements vVerifyingContainer = (ViewAnimator) root.findViewById(R.id.linked_verify_container); vProgress = (ViewAnimator) root.findViewById(R.id.linked_cert_progress); - vIcon = (ImageView) root.findViewById(R.id.linked_cert_icon); vText = (TextView) root.findViewById(R.id.linked_cert_text); } - void setShowProgress(boolean show) { - vProgress.setDisplayedChild(show ? 0 : 1); + enum VerifyState { + VERIFYING, VERIFY_OK, VERIFY_ERROR, CERTIFYING + } + + void setVerifyingState(VerifyState state) { + switch (state) { + case VERIFYING: + vProgress.setDisplayedChild(0); + vText.setText("Verifying…"); + vKeySpinner.setVisibility(View.GONE); + break; + + case VERIFY_OK: + showButton(2); + vText.setText("Ok"); + vProgress.setDisplayedChild(1); + vKeySpinner.setVisibility(View.VISIBLE); + break; + + case VERIFY_ERROR: + showButton(1); + vProgress.setDisplayedChild(2); + vText.setText("Error"); + vKeySpinner.setVisibility(View.GONE); + break; + + case CERTIFYING: + vProgress.setDisplayedChild(0); + vText.setText("Confirming…"); + vKeySpinner.setVisibility(View.GONE); + break; + } } void showButton(int which) { @@ -384,8 +413,7 @@ public class LinkedIdViewFragment extends Fragment implements setShowVerifying(true); mViewHolder.vKeySpinner.setVisibility(View.GONE); - mViewHolder.setShowProgress(true); - mViewHolder.vText.setText("Verifying…"); + mViewHolder.setVerifyingState(VerifyState.VERIFYING); mInProgress = new AsyncTask() { @Override @@ -406,16 +434,13 @@ public class LinkedIdViewFragment extends Fragment implements @Override protected void onPostExecute(LinkedVerifyResult result) { - mViewHolder.setShowProgress(false); if (isCancelled()) { return; } if (result.success()) { - mViewHolder.vText.setText("Ok"); - setupForConfirmation(); + mViewHolder.setVerifyingState(VerifyState.VERIFY_OK); } else { - mViewHolder.showButton(1); - mViewHolder.vText.setText("Error"); + mViewHolder.setVerifyingState(VerifyState.VERIFY_ERROR); } mInProgress = null; } @@ -423,15 +448,6 @@ public class LinkedIdViewFragment extends Fragment implements } - void setupForConfirmation() { - - // button is 'confirm' - mViewHolder.showButton(2); - - mViewHolder.vKeySpinner.setVisibility(View.VISIBLE); - - } - private void initiateCertifying() { // get the user's passphrase for this key (if required) String passphrase; @@ -478,6 +494,8 @@ public class LinkedIdViewFragment extends Fragment implements private void certifyResource(long certifyKeyId, String passphrase) { + mViewHolder.setVerifyingState(VerifyState.CERTIFYING); + Bundle data = new Bundle(); { @@ -502,16 +520,24 @@ public class LinkedIdViewFragment extends Fragment implements intent.putExtra(KeychainIntentService.EXTRA_DATA, data); // Message is received after signing is done in KeychainIntentService - KeychainIntentServiceHandler saveHandler = new KeychainIntentServiceHandler(getActivity(), - getString(R.string.progress_certifying), ProgressDialog.STYLE_SPINNER, false) { + KeychainIntentServiceHandler saveHandler = new KeychainIntentServiceHandler(getActivity()) { public void handleMessage(Message message) { // handle messages by standard KeychainIntentServiceHandler first super.handleMessage(message); + Bundle data = message.getData(); + + if (message.arg1 == KeychainIntentServiceHandler.MESSAGE_UPDATE_PROGRESS) { + if (data.containsKey(DATA_MESSAGE)) { + mViewHolder.vText.setText(data.getString(DATA_MESSAGE)); + } else if (data.containsKey(DATA_MESSAGE_ID)) { + mViewHolder.vText.setText(data.getString(DATA_MESSAGE_ID)); + } + return; + } + if (message.arg1 == KeychainIntentServiceHandler.MESSAGE_OKAY) { - Bundle data = message.getData(); CertifyResult result = data.getParcelable(CertifyResult.EXTRA_RESULT); - result.createNotify(getActivity()).show(); } } @@ -521,9 +547,6 @@ public class LinkedIdViewFragment extends Fragment implements Messenger messenger = new Messenger(saveHandler); intent.putExtra(KeychainIntentService.EXTRA_MESSENGER, messenger); - // show progress dialog - saveHandler.showProgressDialog(getActivity()); - // start service with intent getActivity().startService(intent); -- cgit v1.2.3 From a5e8825882a986bd25455a56e2eab2778fbdf75e Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Thu, 12 Mar 2015 20:46:50 +0100 Subject: finish implementing twitter resource --- .../ui/linked/LinkedIdCreateFinalFragment.java | 14 +++++----- .../linked/LinkedIdCreateTwitterStep1Fragment.java | 14 +++++----- .../linked/LinkedIdCreateTwitterStep2Fragment.java | 31 ++++++++++++---------- .../linked/LinkedIdCreateTwitterStep3Fragment.java | 29 ++++++++------------ 4 files changed, 43 insertions(+), 45 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java index ef76bc9d2..b8d36e0a1 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java @@ -33,7 +33,7 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { public static final String ARG_NONCE = "nonce"; protected static final int REQUEST_CODE_PASSPHRASE = 0x00007008; - private LinkedIdWizard mLinkedIdWizard; + protected LinkedIdWizard mLinkedIdWizard; private ImageView mVerifyImage; private View mVerifyProgress; @@ -113,16 +113,19 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { } } - private void proofVerify() { + protected void proofVerify() { setVerifyProgress(true, null); - final LinkedCookieResource resource = getResource(); - new AsyncTask() { @Override protected LinkedVerifyResult doInBackground(Void... params) { - return resource.verify(mLinkedIdWizard.mFingerprint, mResourceNonce); + LinkedCookieResource resource = getResource(); + LinkedVerifyResult result = resource.verify(mLinkedIdWizard.mFingerprint, mResourceNonce); + if (result.success()) { + mVerifiedResource = resource; + } + return result; } @Override @@ -130,7 +133,6 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { super.onPostExecute(result); if (result.success()) { setVerifyProgress(false, true); - mVerifiedResource = resource; } else { setVerifyProgress(false, false); // on error, show error message diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java index e966fd71f..86579a132 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java @@ -75,7 +75,7 @@ public class LinkedIdCreateTwitterStep1Fragment extends Fragment { @Override protected Boolean doInBackground(Void... params) { - return true; // checkHandle(handle); + return true; // return checkHandle(handle); } @Override @@ -83,21 +83,21 @@ public class LinkedIdCreateTwitterStep1Fragment extends Fragment { super.onPostExecute(result); if (result == null) { - Notify.showNotify(getActivity(), "Connection error while checking username!", Notify.Style.ERROR); + Notify.showNotify(getActivity(), + "Connection error while checking username!", Notify.Style.ERROR); return; } if (!result) { - Notify.showNotify(getActivity(), "This handle does not exist on Twitter!", Notify.Style.ERROR); + Notify.showNotify(getActivity(), + "This handle does not exist on Twitter!", Notify.Style.ERROR); return; } int proofNonce = RawLinkedIdentity.generateNonce(); - String proofText = TwitterResource.generateText(getActivity(), - mLinkedIdWizard.mFingerprint, proofNonce); LinkedIdCreateTwitterStep2Fragment frag = - LinkedIdCreateTwitterStep2Fragment.newInstance(handle, proofNonce, proofText); + LinkedIdCreateTwitterStep2Fragment.newInstance(handle, proofNonce); mLinkedIdWizard.loadFragment(null, frag, LinkedIdWizard.FRAG_ACTION_TO_RIGHT); } @@ -114,7 +114,7 @@ public class LinkedIdCreateTwitterStep1Fragment extends Fragment { }); mEditHandle = (EditText) view.findViewById(R.id.linked_create_twitter_handle); - mEditHandle.setText("Valodim"); + mEditHandle.setText("v_debug"); return view; } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java index 837b84d40..e2fa6d5f6 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java @@ -45,36 +45,46 @@ public class LinkedIdCreateTwitterStep2Fragment extends Fragment { TextView mVerifyStatus, mEditTweetTextLen; String mResourceHandle; - String mResourceNonce, mResourceString; + int mResourceNonce; + String mResourceString; String mCookiePreview; /** * Creates new instance of this fragment */ public static LinkedIdCreateTwitterStep2Fragment newInstance - (String handle, int proofNonce, String proofText) { + (String handle, int proofNonce) { LinkedIdCreateTwitterStep2Fragment frag = new LinkedIdCreateTwitterStep2Fragment(); Bundle args = new Bundle(); args.putString(HANDLE, handle); args.putInt(NONCE, proofNonce); - args.putString(TEXT, proofText); frag.setArguments(args); return frag; } + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + + mLinkedIdWizard = (LinkedIdWizard) getActivity(); + + mResourceHandle = getArguments().getString(HANDLE); + mResourceNonce = getArguments().getInt(NONCE); + + mResourceString = TwitterResource.generateText(getActivity(), + mLinkedIdWizard.mFingerprint, mResourceNonce); + + } + @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { final View view = inflater.inflate(R.layout.linked_create_twitter_fragment_step2, container, false); mCookiePreview = TwitterResource.generatePreview(); - mResourceHandle = getArguments().getString(HANDLE); - mResourceNonce = getArguments().getString(NONCE); - mResourceString = getArguments().getString(TEXT); - view.findViewById(R.id.next_button).setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { @@ -142,11 +152,4 @@ public class LinkedIdCreateTwitterStep2Fragment extends Fragment { return view; } - @Override - public void onActivityCreated(Bundle savedInstanceState) { - super.onActivityCreated(savedInstanceState); - - mLinkedIdWizard = (LinkedIdWizard) getActivity(); - } - } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java index 0c317004b..cfa8d8d23 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java @@ -33,6 +33,7 @@ import android.widget.TextView; import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; +import org.sufficientlysecure.keychain.pgp.linked.resources.TwitterResource; import org.sufficientlysecure.keychain.ui.util.Notify; import java.util.List; @@ -45,15 +46,16 @@ public class LinkedIdCreateTwitterStep3Fragment extends LinkedIdCreateFinalFragm String mResourceHandle, mCustom, mFullString; String mResourceString; + private int mNonce; public static LinkedIdCreateTwitterStep3Fragment newInstance - (String handle, String proofNonce, String proofText, String customText) { + (String handle, int proofNonce, String proofText, String customText) { LinkedIdCreateTwitterStep3Fragment frag = new LinkedIdCreateTwitterStep3Fragment(); Bundle args = new Bundle(); args.putString(ARG_HANDLE, handle); - args.putString(ARG_NONCE, proofNonce); + args.putInt(ARG_NONCE, proofNonce); args.putString(ARG_TEXT, proofText); args.putString(ARG_CUSTOM, customText); frag.setArguments(args); @@ -65,9 +67,11 @@ public class LinkedIdCreateTwitterStep3Fragment extends LinkedIdCreateFinalFragm public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); - mResourceHandle = getArguments().getString(ARG_HANDLE); - mResourceString = getArguments().getString(ARG_TEXT); - mCustom = getArguments().getString(ARG_CUSTOM); + Bundle args = getArguments(); + mResourceHandle = args.getString(ARG_HANDLE); + mResourceString = args.getString(ARG_TEXT); + mCustom = args.getString(ARG_CUSTOM); + mNonce = args.getInt(ARG_NONCE); mFullString = mCustom.isEmpty() ? mResourceString : (mCustom + " " + mResourceString); @@ -94,23 +98,12 @@ public class LinkedIdCreateTwitterStep3Fragment extends LinkedIdCreateFinalFragm } }); - view.findViewById(R.id.next_button).setOnClickListener(new OnClickListener() { - @Override - public void onClick(View v) { - - // AffirmationCreateHttpsStep2Fragment frag = - // AffirmationCreateHttpsStep2Fragment.newInstance(); - - // mAffirmationWizard.loadFragment(null, frag, AffirmationWizard.FRAG_ACTION_TO_RIGHT); - } - }); - return view; } @Override LinkedCookieResource getResource() { - return null; + return TwitterResource.searchInTwitterStream(mResourceHandle, mFullString); } @Override @@ -137,7 +130,7 @@ public class LinkedIdCreateTwitterStep3Fragment extends LinkedIdCreateFinalFragm PackageManager.MATCH_DEFAULT_ONLY); boolean resolved = false; - for(ResolveInfo resolveInfo : resolvedInfoList){ + for(ResolveInfo resolveInfo : resolvedInfoList) { if(resolveInfo.activityInfo.packageName.startsWith("com.twitter.android")) { tweetIntent.setClassName( resolveInfo.activityInfo.packageName, -- cgit v1.2.3 From 4f31bbff0fec6e0ab2122cc0a85ba499e1610e6a Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Thu, 12 Mar 2015 21:03:42 +0100 Subject: ditch custom text step for twitter --- .../linked/LinkedIdCreateTwitterStep1Fragment.java | 6 +- .../linked/LinkedIdCreateTwitterStep2Fragment.java | 155 --------------------- .../linked/LinkedIdCreateTwitterStep3Fragment.java | 31 +++-- 3 files changed, 18 insertions(+), 174 deletions(-) delete mode 100644 OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java index 86579a132..06ca32e2e 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java @@ -94,10 +94,8 @@ public class LinkedIdCreateTwitterStep1Fragment extends Fragment { return; } - int proofNonce = RawLinkedIdentity.generateNonce(); - - LinkedIdCreateTwitterStep2Fragment frag = - LinkedIdCreateTwitterStep2Fragment.newInstance(handle, proofNonce); + LinkedIdCreateTwitterStep3Fragment frag = + LinkedIdCreateTwitterStep3Fragment.newInstance(handle); mLinkedIdWizard.loadFragment(null, frag, LinkedIdWizard.FRAG_ACTION_TO_RIGHT); } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java deleted file mode 100644 index e2fa6d5f6..000000000 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java +++ /dev/null @@ -1,155 +0,0 @@ -/* - * Copyright (C) 2014 Dominik Schürmann - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ - -package org.sufficientlysecure.keychain.ui.linked; - -import android.os.Bundle; -import android.support.v4.app.Fragment; -import android.text.Editable; -import android.text.InputFilter; -import android.text.TextWatcher; -import android.view.LayoutInflater; -import android.view.View; -import android.view.View.OnClickListener; -import android.view.ViewGroup; -import android.widget.EditText; -import android.widget.ImageView; -import android.widget.TextView; - -import org.sufficientlysecure.keychain.R; -import org.sufficientlysecure.keychain.pgp.linked.resources.TwitterResource; - -public class LinkedIdCreateTwitterStep2Fragment extends Fragment { - - public static final String HANDLE = "uri", NONCE = "nonce", TEXT = "text"; - - LinkedIdWizard mLinkedIdWizard; - - EditText mEditTweetCustom, mEditTweetPreview; - ImageView mVerifyImage; - View mVerifyProgress; - TextView mVerifyStatus, mEditTweetTextLen; - - String mResourceHandle; - int mResourceNonce; - String mResourceString; - String mCookiePreview; - - /** - * Creates new instance of this fragment - */ - public static LinkedIdCreateTwitterStep2Fragment newInstance - (String handle, int proofNonce) { - - LinkedIdCreateTwitterStep2Fragment frag = new LinkedIdCreateTwitterStep2Fragment(); - - Bundle args = new Bundle(); - args.putString(HANDLE, handle); - args.putInt(NONCE, proofNonce); - frag.setArguments(args); - - return frag; - } - - @Override - public void onCreate(Bundle savedInstanceState) { - super.onCreate(savedInstanceState); - - mLinkedIdWizard = (LinkedIdWizard) getActivity(); - - mResourceHandle = getArguments().getString(HANDLE); - mResourceNonce = getArguments().getInt(NONCE); - - mResourceString = TwitterResource.generateText(getActivity(), - mLinkedIdWizard.mFingerprint, mResourceNonce); - - } - - @Override - public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { - final View view = inflater.inflate(R.layout.linked_create_twitter_fragment_step2, container, false); - - mCookiePreview = TwitterResource.generatePreview(); - - view.findViewById(R.id.next_button).setOnClickListener(new OnClickListener() { - @Override - public void onClick(View v) { - - LinkedIdCreateTwitterStep3Fragment frag = - LinkedIdCreateTwitterStep3Fragment.newInstance(mResourceHandle, - mResourceNonce, mResourceString, - mEditTweetCustom.getText().toString()); - - mLinkedIdWizard.loadFragment(null, frag, LinkedIdWizard.FRAG_ACTION_TO_RIGHT); - } - }); - - view.findViewById(R.id.back_button).setOnClickListener(new View.OnClickListener() { - @Override - public void onClick(View v) { - mLinkedIdWizard.loadFragment(null, null, LinkedIdWizard.FRAG_ACTION_TO_LEFT); - } - }); - - mVerifyImage = (ImageView) view.findViewById(R.id.verify_image); - mVerifyProgress = view.findViewById(R.id.verify_progress); - mVerifyStatus = (TextView) view.findViewById(R.id.verify_status); - - mEditTweetPreview = (EditText) view.findViewById(R.id.linked_create_twitter_preview); - mEditTweetPreview.setText(mCookiePreview); - - mEditTweetCustom = (EditText) view.findViewById(R.id.linked_create_twitter_custom); - mEditTweetCustom.setFilters(new InputFilter[] { - new InputFilter.LengthFilter(139 - mResourceString.length()) - }); - - mEditTweetTextLen = (TextView) view.findViewById(R.id.linked_create_twitter_textlen); - mEditTweetTextLen.setText(mResourceString.length() + "/140"); - - mEditTweetCustom.addTextChangedListener(new TextWatcher() { - @Override - public void beforeTextChanged(CharSequence charSequence, int i, int i2, int i3) { - } - - @Override - public void onTextChanged(CharSequence charSequence, int i, int i2, int i3) { - } - - @Override - public void afterTextChanged(Editable editable) { - if (editable != null && editable.length() > 0) { - String str = editable + " " + mCookiePreview; - mEditTweetPreview.setText(str); - - mEditTweetTextLen.setText( - (editable.length() + mResourceString.length() + 1) + "/140"); - mEditTweetTextLen.setTextColor(getResources().getColor(str.length() == 140 - ? R.color.android_red_dark - : R.color.primary_dark_material_light)); - - - } else { - mEditTweetPreview.setText(mCookiePreview); - mEditTweetTextLen.setText(mResourceString.length() + "/140"); - } - } - }); - - return view; - } - -} diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java index cfa8d8d23..ce0526efc 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java @@ -33,6 +33,9 @@ import android.widget.TextView; import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; +import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; +import org.sufficientlysecure.keychain.pgp.linked.LinkedResource; +import org.sufficientlysecure.keychain.pgp.linked.RawLinkedIdentity; import org.sufficientlysecure.keychain.pgp.linked.resources.TwitterResource; import org.sufficientlysecure.keychain.ui.util.Notify; @@ -40,24 +43,24 @@ import java.util.List; public class LinkedIdCreateTwitterStep3Fragment extends LinkedIdCreateFinalFragment { - public static final String ARG_HANDLE = "uri", ARG_TEXT = "text", ARG_CUSTOM = "custom"; + public static final String ARG_HANDLE = "handle"; EditText mEditTweetPreview; - String mResourceHandle, mCustom, mFullString; + String mResourceHandle; String mResourceString; private int mNonce; public static LinkedIdCreateTwitterStep3Fragment newInstance - (String handle, int proofNonce, String proofText, String customText) { + (String handle) { LinkedIdCreateTwitterStep3Fragment frag = new LinkedIdCreateTwitterStep3Fragment(); + int proofNonce = RawLinkedIdentity.generateNonce(); + Bundle args = new Bundle(); args.putString(ARG_HANDLE, handle); args.putInt(ARG_NONCE, proofNonce); - args.putString(ARG_TEXT, proofText); - args.putString(ARG_CUSTOM, customText); frag.setArguments(args); return frag; @@ -67,13 +70,11 @@ public class LinkedIdCreateTwitterStep3Fragment extends LinkedIdCreateFinalFragm public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); - Bundle args = getArguments(); - mResourceHandle = args.getString(ARG_HANDLE); - mResourceString = args.getString(ARG_TEXT); - mCustom = args.getString(ARG_CUSTOM); - mNonce = args.getInt(ARG_NONCE); + mNonce = LinkedIdentity.generateNonce(); + mResourceString = + TwitterResource.generate(getActivity(), mLinkedIdWizard.mFingerprint, mNonce); - mFullString = mCustom.isEmpty() ? mResourceString : (mCustom + " " + mResourceString); + mResourceHandle = getArguments().getString(ARG_HANDLE); } @@ -82,7 +83,7 @@ public class LinkedIdCreateTwitterStep3Fragment extends LinkedIdCreateFinalFragm View view = super.onCreateView(inflater, container, savedInstanceState); mEditTweetPreview = (EditText) view.findViewById(R.id.linked_create_twitter_preview); - mEditTweetPreview.setText(mFullString); + mEditTweetPreview.setText(mResourceString); view.findViewById(R.id.button_send).setOnClickListener(new OnClickListener() { @Override @@ -103,7 +104,7 @@ public class LinkedIdCreateTwitterStep3Fragment extends LinkedIdCreateFinalFragm @Override LinkedCookieResource getResource() { - return TwitterResource.searchInTwitterStream(mResourceHandle, mFullString); + return TwitterResource.searchInTwitterStream(mResourceHandle, mResourceString); } @Override @@ -114,7 +115,7 @@ public class LinkedIdCreateTwitterStep3Fragment extends LinkedIdCreateFinalFragm private void proofShare() { Intent sendIntent = new Intent(); sendIntent.setAction(Intent.ACTION_SEND); - sendIntent.putExtra(Intent.EXTRA_TEXT, mFullString); + sendIntent.putExtra(Intent.EXTRA_TEXT, mResourceString); sendIntent.setType("text/plain"); startActivity(sendIntent); } @@ -122,7 +123,7 @@ public class LinkedIdCreateTwitterStep3Fragment extends LinkedIdCreateFinalFragm private void proofSend() { Intent tweetIntent = new Intent(Intent.ACTION_SEND); - tweetIntent.putExtra(Intent.EXTRA_TEXT, mFullString); + tweetIntent.putExtra(Intent.EXTRA_TEXT, mResourceString); tweetIntent.setType("text/plain"); PackageManager packManager = getActivity().getPackageManager(); -- cgit v1.2.3 From bebd72638460a2c6b27a9fb518326851d6019f23 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Thu, 12 Mar 2015 21:07:43 +0100 Subject: twitter Step3 -> Step2 --- .../linked/LinkedIdCreateTwitterStep1Fragment.java | 6 +- .../linked/LinkedIdCreateTwitterStep2Fragment.java | 149 ++++++++++++++++++++ .../linked/LinkedIdCreateTwitterStep3Fragment.java | 154 --------------------- 3 files changed, 151 insertions(+), 158 deletions(-) create mode 100644 OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java delete mode 100644 OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java index 06ca32e2e..081b949d5 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java @@ -27,8 +27,6 @@ import android.view.ViewGroup; import android.widget.EditText; import org.sufficientlysecure.keychain.R; -import org.sufficientlysecure.keychain.pgp.linked.RawLinkedIdentity; -import org.sufficientlysecure.keychain.pgp.linked.resources.TwitterResource; import org.sufficientlysecure.keychain.ui.util.Notify; import java.io.IOException; @@ -94,8 +92,8 @@ public class LinkedIdCreateTwitterStep1Fragment extends Fragment { return; } - LinkedIdCreateTwitterStep3Fragment frag = - LinkedIdCreateTwitterStep3Fragment.newInstance(handle); + LinkedIdCreateTwitterStep2Fragment frag = + LinkedIdCreateTwitterStep2Fragment.newInstance(handle); mLinkedIdWizard.loadFragment(null, frag, LinkedIdWizard.FRAG_ACTION_TO_RIGHT); } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java new file mode 100644 index 000000000..1074a8e61 --- /dev/null +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java @@ -0,0 +1,149 @@ +/* + * Copyright (C) 2014 Dominik Schürmann + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package org.sufficientlysecure.keychain.ui.linked; + +import android.content.Intent; +import android.content.pm.PackageManager; +import android.content.pm.ResolveInfo; +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.View.OnClickListener; +import android.view.ViewGroup; +import android.widget.EditText; + +import org.sufficientlysecure.keychain.R; +import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; +import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; +import org.sufficientlysecure.keychain.pgp.linked.RawLinkedIdentity; +import org.sufficientlysecure.keychain.pgp.linked.resources.TwitterResource; +import org.sufficientlysecure.keychain.ui.util.Notify; + +import java.util.List; + +public class LinkedIdCreateTwitterStep2Fragment extends LinkedIdCreateFinalFragment { + + public static final String ARG_HANDLE = "handle"; + + EditText mEditTweetPreview; + + String mResourceHandle; + String mResourceString; + private int mNonce; + + public static LinkedIdCreateTwitterStep2Fragment newInstance + (String handle) { + + LinkedIdCreateTwitterStep2Fragment frag = new LinkedIdCreateTwitterStep2Fragment(); + + int proofNonce = RawLinkedIdentity.generateNonce(); + + Bundle args = new Bundle(); + args.putString(ARG_HANDLE, handle); + args.putInt(ARG_NONCE, proofNonce); + frag.setArguments(args); + + return frag; + } + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + + mNonce = LinkedIdentity.generateNonce(); + mResourceString = + TwitterResource.generate(getActivity(), mLinkedIdWizard.mFingerprint, mNonce); + + mResourceHandle = getArguments().getString(ARG_HANDLE); + + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + View view = super.onCreateView(inflater, container, savedInstanceState); + + mEditTweetPreview = (EditText) view.findViewById(R.id.linked_create_twitter_preview); + mEditTweetPreview.setText(mResourceString); + + view.findViewById(R.id.button_send).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + proofSend(); + } + }); + + view.findViewById(R.id.button_share).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + proofShare(); + } + }); + + return view; + } + + @Override + LinkedCookieResource getResource() { + return TwitterResource.searchInTwitterStream(mResourceHandle, mResourceString); + } + + @Override + protected View newView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + return inflater.inflate(R.layout.linked_create_twitter_fragment_step3, container, false); + } + + private void proofShare() { + Intent sendIntent = new Intent(); + sendIntent.setAction(Intent.ACTION_SEND); + sendIntent.putExtra(Intent.EXTRA_TEXT, mResourceString); + sendIntent.setType("text/plain"); + startActivity(sendIntent); + } + + private void proofSend() { + + Intent tweetIntent = new Intent(Intent.ACTION_SEND); + tweetIntent.putExtra(Intent.EXTRA_TEXT, mResourceString); + tweetIntent.setType("text/plain"); + + PackageManager packManager = getActivity().getPackageManager(); + List resolvedInfoList = packManager.queryIntentActivities(tweetIntent, + PackageManager.MATCH_DEFAULT_ONLY); + + boolean resolved = false; + for(ResolveInfo resolveInfo : resolvedInfoList) { + if(resolveInfo.activityInfo.packageName.startsWith("com.twitter.android")) { + tweetIntent.setClassName( + resolveInfo.activityInfo.packageName, + resolveInfo.activityInfo.name ); + resolved = true; + break; + } + } + + if (resolved) { + startActivity(tweetIntent); + } else { + Notify.showNotify(getActivity(), + "Twitter app is not installed, please use the send intent!", + Notify.Style.ERROR); + } + + } + +} diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java deleted file mode 100644 index ce0526efc..000000000 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep3Fragment.java +++ /dev/null @@ -1,154 +0,0 @@ -/* - * Copyright (C) 2014 Dominik Schürmann - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ - -package org.sufficientlysecure.keychain.ui.linked; - -import android.content.Intent; -import android.content.pm.PackageManager; -import android.content.pm.ResolveInfo; -import android.graphics.PorterDuff; -import android.os.Bundle; -import android.support.v4.app.Fragment; -import android.view.LayoutInflater; -import android.view.View; -import android.view.View.OnClickListener; -import android.view.ViewGroup; -import android.widget.EditText; -import android.widget.ImageView; -import android.widget.TextView; - -import org.sufficientlysecure.keychain.R; -import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; -import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; -import org.sufficientlysecure.keychain.pgp.linked.LinkedResource; -import org.sufficientlysecure.keychain.pgp.linked.RawLinkedIdentity; -import org.sufficientlysecure.keychain.pgp.linked.resources.TwitterResource; -import org.sufficientlysecure.keychain.ui.util.Notify; - -import java.util.List; - -public class LinkedIdCreateTwitterStep3Fragment extends LinkedIdCreateFinalFragment { - - public static final String ARG_HANDLE = "handle"; - - EditText mEditTweetPreview; - - String mResourceHandle; - String mResourceString; - private int mNonce; - - public static LinkedIdCreateTwitterStep3Fragment newInstance - (String handle) { - - LinkedIdCreateTwitterStep3Fragment frag = new LinkedIdCreateTwitterStep3Fragment(); - - int proofNonce = RawLinkedIdentity.generateNonce(); - - Bundle args = new Bundle(); - args.putString(ARG_HANDLE, handle); - args.putInt(ARG_NONCE, proofNonce); - frag.setArguments(args); - - return frag; - } - - @Override - public void onCreate(Bundle savedInstanceState) { - super.onCreate(savedInstanceState); - - mNonce = LinkedIdentity.generateNonce(); - mResourceString = - TwitterResource.generate(getActivity(), mLinkedIdWizard.mFingerprint, mNonce); - - mResourceHandle = getArguments().getString(ARG_HANDLE); - - } - - @Override - public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { - View view = super.onCreateView(inflater, container, savedInstanceState); - - mEditTweetPreview = (EditText) view.findViewById(R.id.linked_create_twitter_preview); - mEditTweetPreview.setText(mResourceString); - - view.findViewById(R.id.button_send).setOnClickListener(new OnClickListener() { - @Override - public void onClick(View v) { - proofSend(); - } - }); - - view.findViewById(R.id.button_share).setOnClickListener(new OnClickListener() { - @Override - public void onClick(View v) { - proofShare(); - } - }); - - return view; - } - - @Override - LinkedCookieResource getResource() { - return TwitterResource.searchInTwitterStream(mResourceHandle, mResourceString); - } - - @Override - protected View newView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { - return inflater.inflate(R.layout.linked_create_twitter_fragment_step3, container, false); - } - - private void proofShare() { - Intent sendIntent = new Intent(); - sendIntent.setAction(Intent.ACTION_SEND); - sendIntent.putExtra(Intent.EXTRA_TEXT, mResourceString); - sendIntent.setType("text/plain"); - startActivity(sendIntent); - } - - private void proofSend() { - - Intent tweetIntent = new Intent(Intent.ACTION_SEND); - tweetIntent.putExtra(Intent.EXTRA_TEXT, mResourceString); - tweetIntent.setType("text/plain"); - - PackageManager packManager = getActivity().getPackageManager(); - List resolvedInfoList = packManager.queryIntentActivities(tweetIntent, - PackageManager.MATCH_DEFAULT_ONLY); - - boolean resolved = false; - for(ResolveInfo resolveInfo : resolvedInfoList) { - if(resolveInfo.activityInfo.packageName.startsWith("com.twitter.android")) { - tweetIntent.setClassName( - resolveInfo.activityInfo.packageName, - resolveInfo.activityInfo.name ); - resolved = true; - break; - } - } - - if (resolved) { - startActivity(tweetIntent); - } else { - Notify.showNotify(getActivity(), - "Twitter app is not installed, please use the send intent!", - Notify.Style.ERROR); - } - - } - -} -- cgit v1.2.3 From 4adf2b343ce2fbf9749c413209e3c2fd96f14e44 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Thu, 12 Mar 2015 22:06:30 +0100 Subject: small fix for CreateFinalFragment --- .../keychain/ui/linked/LinkedIdCreateFinalFragment.java | 4 ++-- .../keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java | 3 --- 2 files changed, 2 insertions(+), 5 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java index b8d36e0a1..07f47c31f 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java @@ -44,8 +44,8 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { LinkedCookieResource mVerifiedResource = null; @Override - public void onActivityCreated(Bundle savedInstanceState) { - super.onActivityCreated(savedInstanceState); + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); mLinkedIdWizard = (LinkedIdWizard) getActivity(); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java index 081b949d5..c22351f87 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java @@ -39,9 +39,6 @@ public class LinkedIdCreateTwitterStep1Fragment extends Fragment { EditText mEditHandle; - /** - * Creates new instance of this fragment - */ public static LinkedIdCreateTwitterStep1Fragment newInstance() { LinkedIdCreateTwitterStep1Fragment frag = new LinkedIdCreateTwitterStep1Fragment(); -- cgit v1.2.3 From 163cbb04a00f298a26cd7a2ba19d107a5a8c233c Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Thu, 12 Mar 2015 22:35:14 +0100 Subject: twitter layout step3 -> step2 --- .../keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java index 1074a8e61..262277700 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java @@ -104,7 +104,7 @@ public class LinkedIdCreateTwitterStep2Fragment extends LinkedIdCreateFinalFragm @Override protected View newView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { - return inflater.inflate(R.layout.linked_create_twitter_fragment_step3, container, false); + return inflater.inflate(R.layout.linked_create_twitter_fragment_step2, container, false); } private void proofShare() { -- cgit v1.2.3 From a9a5551d95d964b5037fb2e5308081618a33b802 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Fri, 13 Mar 2015 01:55:31 +0100 Subject: remove notiion of nonce/identifier --- .../keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java | 5 ++--- .../keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java | 3 +-- .../keychain/ui/linked/LinkedIdCreateFinalFragment.java | 8 ++------ .../keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java | 8 ++------ .../keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java | 3 +-- .../keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java | 9 +-------- .../keychain/ui/linked/LinkedIdViewFragment.java | 4 +--- 7 files changed, 10 insertions(+), 30 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java index 26b0a0539..6b3eef26a 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java @@ -73,12 +73,11 @@ public class LinkedIdCreateDnsStep1Fragment extends Fragment { return; } - int proofNonce = RawLinkedIdentity.generateNonce(); String proofText = DnsResource.generateText(getActivity(), - mLinkedIdWizard.mFingerprint, proofNonce); + mLinkedIdWizard.mFingerprint); LinkedIdCreateDnsStep2Fragment frag = - LinkedIdCreateDnsStep2Fragment.newInstance(uri, proofNonce, proofText); + LinkedIdCreateDnsStep2Fragment.newInstance(uri, proofText); mLinkedIdWizard.loadFragment(null, frag, LinkedIdWizard.FRAG_ACTION_TO_RIGHT); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java index de3a63256..8715c0a2e 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java @@ -52,12 +52,11 @@ public class LinkedIdCreateDnsStep2Fragment extends LinkedIdCreateFinalFragment String mResourceString; public static LinkedIdCreateDnsStep2Fragment newInstance - (String uri, int proofNonce, String proofText) { + (String uri, String proofText) { LinkedIdCreateDnsStep2Fragment frag = new LinkedIdCreateDnsStep2Fragment(); Bundle args = new Bundle(); - args.putInt(ARG_NONCE, proofNonce); args.putString(DOMAIN, uri); args.putString(TEXT, proofText); frag.setArguments(args); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java index 07f47c31f..7be967907 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java @@ -30,7 +30,6 @@ import org.sufficientlysecure.keychain.ui.util.Notify; public abstract class LinkedIdCreateFinalFragment extends Fragment { - public static final String ARG_NONCE = "nonce"; protected static final int REQUEST_CODE_PASSPHRASE = 0x00007008; protected LinkedIdWizard mLinkedIdWizard; @@ -38,7 +37,6 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { private ImageView mVerifyImage; private View mVerifyProgress; private TextView mVerifyStatus; - private int mResourceNonce; // This is a resource, set AFTER it has been verified LinkedCookieResource mVerifiedResource = null; @@ -48,8 +46,6 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { super.onCreate(savedInstanceState); mLinkedIdWizard = (LinkedIdWizard) getActivity(); - - mResourceNonce = getArguments().getInt(ARG_NONCE); } protected abstract View newView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState); @@ -121,7 +117,7 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { @Override protected LinkedVerifyResult doInBackground(Void... params) { LinkedCookieResource resource = getResource(); - LinkedVerifyResult result = resource.verify(mLinkedIdWizard.mFingerprint, mResourceNonce); + LinkedVerifyResult result = resource.verify(mLinkedIdWizard.mFingerprint); if (result.success()) { mVerifiedResource = resource; } @@ -195,7 +191,7 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { new SaveKeyringParcel(mLinkedIdWizard.mMasterKeyId, mLinkedIdWizard.mFingerprint); WrappedUserAttribute ua = - LinkedIdentity.fromResource(mVerifiedResource, mResourceNonce).toUserAttribute(); + LinkedIdentity.fromResource(mVerifiedResource).toUserAttribute(); skp.mAddUserAttribute.add(ua); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java index 78ca4cfe9..72669142b 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java @@ -38,9 +38,6 @@ public class LinkedIdCreateHttpsStep1Fragment extends Fragment { EditText mEditUri; - /** - * Creates new instance of this fragment - */ public static LinkedIdCreateHttpsStep1Fragment newInstance() { LinkedIdCreateHttpsStep1Fragment frag = new LinkedIdCreateHttpsStep1Fragment(); @@ -72,12 +69,11 @@ public class LinkedIdCreateHttpsStep1Fragment extends Fragment { return; } - int proofNonce = RawLinkedIdentity.generateNonce(); String proofText = GenericHttpsResource.generateText(getActivity(), - mLinkedIdWizard.mFingerprint, proofNonce); + mLinkedIdWizard.mFingerprint); LinkedIdCreateHttpsStep2Fragment frag = - LinkedIdCreateHttpsStep2Fragment.newInstance(uri, proofNonce, proofText); + LinkedIdCreateHttpsStep2Fragment.newInstance(uri, proofText); mLinkedIdWizard.loadFragment(null, frag, LinkedIdWizard.FRAG_ACTION_TO_RIGHT); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java index adae7eaf5..55ac6e075 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java @@ -53,12 +53,11 @@ public class LinkedIdCreateHttpsStep2Fragment extends LinkedIdCreateFinalFragmen String mResourceString; public static LinkedIdCreateHttpsStep2Fragment newInstance - (String uri, int proofNonce, String proofText) { + (String uri, String proofText) { LinkedIdCreateHttpsStep2Fragment frag = new LinkedIdCreateHttpsStep2Fragment(); Bundle args = new Bundle(); - args.putInt(ARG_NONCE, proofNonce); args.putString(ARG_URI, uri); args.putString(ARG_TEXT, proofText); frag.setArguments(args); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java index 262277700..fa0b2911c 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java @@ -29,8 +29,6 @@ import android.widget.EditText; import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; -import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; -import org.sufficientlysecure.keychain.pgp.linked.RawLinkedIdentity; import org.sufficientlysecure.keychain.pgp.linked.resources.TwitterResource; import org.sufficientlysecure.keychain.ui.util.Notify; @@ -44,18 +42,14 @@ public class LinkedIdCreateTwitterStep2Fragment extends LinkedIdCreateFinalFragm String mResourceHandle; String mResourceString; - private int mNonce; public static LinkedIdCreateTwitterStep2Fragment newInstance (String handle) { LinkedIdCreateTwitterStep2Fragment frag = new LinkedIdCreateTwitterStep2Fragment(); - int proofNonce = RawLinkedIdentity.generateNonce(); - Bundle args = new Bundle(); args.putString(ARG_HANDLE, handle); - args.putInt(ARG_NONCE, proofNonce); frag.setArguments(args); return frag; @@ -65,9 +59,8 @@ public class LinkedIdCreateTwitterStep2Fragment extends LinkedIdCreateFinalFragm public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); - mNonce = LinkedIdentity.generateNonce(); mResourceString = - TwitterResource.generate(getActivity(), mLinkedIdWizard.mFingerprint, mNonce); + TwitterResource.generate(getActivity(), mLinkedIdWizard.mFingerprint); mResourceHandle = getArguments().getString(ARG_HANDLE); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index 742459ff8..98adb5889 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -4,7 +4,6 @@ import java.io.IOException; import java.util.Arrays; import android.app.Activity; -import android.app.ProgressDialog; import android.content.Context; import android.content.Intent; import android.database.Cursor; @@ -24,7 +23,6 @@ import android.view.LayoutInflater; import android.view.View; import android.view.View.OnClickListener; import android.view.ViewGroup; -import android.widget.ImageView; import android.widget.TextView; import android.widget.ViewAnimator; @@ -419,7 +417,7 @@ public class LinkedIdViewFragment extends Fragment implements @Override protected LinkedVerifyResult doInBackground(Void... params) { long timer = System.currentTimeMillis(); - LinkedVerifyResult result = mLinkedResource.verify(mFingerprint, mLinkedId.mNonce); + LinkedVerifyResult result = mLinkedResource.verify(mFingerprint); // ux flow: this operation should take at last a second timer = System.currentTimeMillis() -timer; -- cgit v1.2.3 From 8fcffdd7cd1732b10ed6872fc88aead356fd7dbd Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Fri, 13 Mar 2015 13:54:52 +0100 Subject: use ViewAnimator for progress, streamline text on first step --- .../keychain/ui/linked/LinkedIdCreateFinalFragment.java | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java index 7be967907..38dce0c17 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java @@ -15,6 +15,7 @@ import android.view.View.OnClickListener; import android.view.ViewGroup; import android.widget.ImageView; import android.widget.TextView; +import android.widget.ViewAnimator; import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.operations.results.LinkedVerifyResult; @@ -35,8 +36,8 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { protected LinkedIdWizard mLinkedIdWizard; private ImageView mVerifyImage; - private View mVerifyProgress; private TextView mVerifyStatus; + private ViewAnimator mVerifyAnimator; // This is a resource, set AFTER it has been verified LinkedCookieResource mVerifiedResource = null; @@ -69,7 +70,7 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { }); mVerifyImage = (ImageView) view.findViewById(R.id.verify_image); - mVerifyProgress = view.findViewById(R.id.verify_progress); + mVerifyAnimator = (ViewAnimator) view.findViewById(R.id.verify_progress); mVerifyStatus = (TextView) view.findViewById(R.id.verify_status); view.findViewById(R.id.button_verify).setOnClickListener(new OnClickListener() { @@ -89,13 +90,8 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { abstract LinkedCookieResource getResource(); private void setVerifyProgress(boolean on, Boolean success) { - mVerifyProgress.setVisibility(on ? View.VISIBLE : View.GONE); - mVerifyImage.setVisibility(on ? View.GONE : View.VISIBLE); if (success == null) { mVerifyStatus.setText(R.string.linked_verifying); - mVerifyImage.setImageResource(R.drawable.status_signature_unverified_cutout_24dp); - mVerifyImage.setColorFilter(getResources().getColor(R.color.tertiary_text_light), - PorterDuff.Mode.SRC_IN); } else if (success) { mVerifyStatus.setText(R.string.linked_verify_success); mVerifyImage.setImageResource(R.drawable.status_signature_verified_cutout_24dp); @@ -107,6 +103,7 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { mVerifyImage.setColorFilter(getResources().getColor(R.color.android_red_dark), PorterDuff.Mode.SRC_IN); } + mVerifyAnimator.setDisplayedChild(on ? 1 : 0); } protected void proofVerify() { -- cgit v1.2.3 From 4c122dfb601e65a145019d26270ab4ec6c56df04 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Fri, 13 Mar 2015 14:07:37 +0100 Subject: verification takes a second at least --- .../keychain/ui/linked/LinkedIdCreateFinalFragment.java | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java index 38dce0c17..040c26aab 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java @@ -86,7 +86,6 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { return view; } - abstract LinkedCookieResource getResource(); private void setVerifyProgress(boolean on, Boolean success) { @@ -113,8 +112,19 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { @Override protected LinkedVerifyResult doInBackground(Void... params) { + long timer = System.currentTimeMillis(); + LinkedCookieResource resource = getResource(); LinkedVerifyResult result = resource.verify(mLinkedIdWizard.mFingerprint); + + // ux flow: this operation should take at last a second + timer = System.currentTimeMillis() -timer; + if (timer < 1000) try { + Thread.sleep(1000 -timer); + } catch (InterruptedException e) { + // never mind + } + if (result.success()) { mVerifiedResource = resource; } -- cgit v1.2.3 From 9e379fd19c2b6caf4cfcba2c485a0380eb971e88 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Fri, 13 Mar 2015 14:37:52 +0100 Subject: improve error handling in LinkedIdViewFragment, disable unknown identity types (for now?) --- .../keychain/ui/linked/LinkedIdViewFragment.java | 31 +++++++++++++++++----- 1 file changed, 24 insertions(+), 7 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index 98adb5889..9501e454c 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -48,6 +48,8 @@ import org.sufficientlysecure.keychain.ui.adapter.UserIdsAdapter; import org.sufficientlysecure.keychain.ui.linked.LinkedIdViewFragment.ViewHolder.VerifyState; import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils; import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils.State; +import org.sufficientlysecure.keychain.ui.util.Notify; +import org.sufficientlysecure.keychain.ui.util.Notify.Style; import org.sufficientlysecure.keychain.ui.widget.CertListWidget; import org.sufficientlysecure.keychain.ui.widget.CertifyKeySpinner; import org.sufficientlysecure.keychain.util.Log; @@ -127,10 +129,10 @@ public class LinkedIdViewFragment extends Fragment implements switch (loader.getId()) { case LOADER_ID_LINKED_ID: - // TODO proper error reporting and null checks here! - if (!cursor.moveToFirst()) { - Log.e(Constants.TAG, "error"); + Notify.createNotify(getActivity(), "Error loading identity!", + Notify.LENGTH_LONG, Style.ERROR).show(); + finishFragment(); break; } @@ -148,14 +150,22 @@ public class LinkedIdViewFragment extends Fragment implements } } catch (IOException e) { - e.printStackTrace(); - throw new AssertionError("reconstruction of user attribute must succeed!"); + Log.e(Constants.TAG, "error parsing identity", e); + Notify.createNotify(getActivity(), "Error parsing identity!", + Notify.LENGTH_LONG, Style.ERROR).show(); + finishFragment(); } break; } } + public void finishFragment() { + FragmentManager manager = getFragmentManager(); + manager.removeOnBackStackChangedListener(this); + manager.popBackStack("linked_id", FragmentManager.POP_BACK_STACK_INCLUSIVE); + } + public interface OnIdentityLoadedListener { public void onIdentityLoaded(); } @@ -296,6 +306,13 @@ public class LinkedIdViewFragment extends Fragment implements } } + void showVerifyingContainer(boolean show) { + if (vVerifyingContainer.getDisplayedChild() == (show ? 1 : 0)) { + return; + } + vVerifyingContainer.setDisplayedChild(show ? 1 : 0); + } + void showButton(int which) { if (vButtonSwitcher.getDisplayedChild() == which) { return; @@ -335,7 +352,7 @@ public class LinkedIdViewFragment extends Fragment implements mViewHolder.showButton(0); mViewHolder.vKeySpinner.setVisibility(View.GONE); - mViewHolder.vVerifyingContainer.setDisplayedChild(0); + mViewHolder.showVerifyingContainer(false); return; } @@ -348,7 +365,7 @@ public class LinkedIdViewFragment extends Fragment implements manager.beginTransaction().addToBackStack("verification").commit(); manager.executePendingTransactions(); manager.addOnBackStackChangedListener(this); - mViewHolder.vVerifyingContainer.setDisplayedChild(1); + mViewHolder.showVerifyingContainer(true); } -- cgit v1.2.3 From 9e3125c15eea3a9df33577ef613086b1f0efea27 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Fri, 13 Mar 2015 14:58:06 +0100 Subject: don't filter tweet intent --- .../linked/LinkedIdCreateTwitterStep2Fragment.java | 37 ++++------------------ 1 file changed, 6 insertions(+), 31 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java index fa0b2911c..f8322d3c4 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java @@ -18,8 +18,7 @@ package org.sufficientlysecure.keychain.ui.linked; import android.content.Intent; -import android.content.pm.PackageManager; -import android.content.pm.ResolveInfo; +import android.net.Uri; import android.os.Bundle; import android.view.LayoutInflater; import android.view.View; @@ -30,9 +29,6 @@ import android.widget.EditText; import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; import org.sufficientlysecure.keychain.pgp.linked.resources.TwitterResource; -import org.sufficientlysecure.keychain.ui.util.Notify; - -import java.util.List; public class LinkedIdCreateTwitterStep2Fragment extends LinkedIdCreateFinalFragment { @@ -110,33 +106,12 @@ public class LinkedIdCreateTwitterStep2Fragment extends LinkedIdCreateFinalFragm private void proofSend() { - Intent tweetIntent = new Intent(Intent.ACTION_SEND); - tweetIntent.putExtra(Intent.EXTRA_TEXT, mResourceString); - tweetIntent.setType("text/plain"); - - PackageManager packManager = getActivity().getPackageManager(); - List resolvedInfoList = packManager.queryIntentActivities(tweetIntent, - PackageManager.MATCH_DEFAULT_ONLY); - - boolean resolved = false; - for(ResolveInfo resolveInfo : resolvedInfoList) { - if(resolveInfo.activityInfo.packageName.startsWith("com.twitter.android")) { - tweetIntent.setClassName( - resolveInfo.activityInfo.packageName, - resolveInfo.activityInfo.name ); - resolved = true; - break; - } - } - - if (resolved) { - startActivity(tweetIntent); - } else { - Notify.showNotify(getActivity(), - "Twitter app is not installed, please use the send intent!", - Notify.Style.ERROR); - } + Uri.Builder builder = Uri.parse("https://twitter.com/intent/tweet").buildUpon(); + builder.appendQueryParameter("text", mResourceString); + Uri uri = builder.build(); + Intent intent = new Intent(Intent.ACTION_VIEW, uri); + getActivity().startActivity(intent); } } -- cgit v1.2.3 From 3f844cc70b487507f1f41f50b1d9867463b2161b Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Fri, 13 Mar 2015 16:30:49 +0100 Subject: work on second step of identity creation --- .../ui/linked/LinkedIdCreateDnsStep2Fragment.java | 22 +++++----------------- .../ui/linked/LinkedIdCreateFinalFragment.java | 21 ++++++++++++++++++++- .../linked/LinkedIdCreateTwitterStep2Fragment.java | 5 ----- 3 files changed, 25 insertions(+), 23 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java index 8715c0a2e..2e6181f07 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java @@ -30,6 +30,7 @@ import android.widget.TextView; import org.sufficientlysecure.keychain.Constants; import org.sufficientlysecure.keychain.R; +import org.sufficientlysecure.keychain.compatibility.ClipboardReflection; import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; import org.sufficientlysecure.keychain.pgp.linked.resources.DnsResource; import org.sufficientlysecure.keychain.ui.util.Notify; @@ -92,7 +93,7 @@ public class LinkedIdCreateDnsStep2Fragment extends LinkedIdCreateFinalFragment view.findViewById(R.id.button_save).setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { - proofSave(); + proofToClipboard(); } }); @@ -115,22 +116,9 @@ public class LinkedIdCreateDnsStep2Fragment extends LinkedIdCreateFinalFragment startActivity(sendIntent); } - private void proofSave () { - String state = Environment.getExternalStorageState(); - if (!Environment.MEDIA_MOUNTED.equals(state)) { - Notify.showNotify(getActivity(), "External storage not available!", Style.ERROR); - return; - } - - String targetName = "pgpkey.txt"; - - if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) { - File targetFile = new File(Constants.Path.APP_DIR, targetName); - FileHelper.saveFile(this, getString(R.string.title_decrypt_to_file), - getString(R.string.specify_file_to_decrypt_to), targetFile, REQUEST_CODE_OUTPUT); - } else { - FileHelper.saveDocument(this, "text/plain", targetName, REQUEST_CODE_OUTPUT); - } + private void proofToClipboard() { + ClipboardReflection.copyToClipboard(getActivity(), mResourceString); + Notify.showNotify(getActivity(), R.string.linked_text_clipboard, Notify.Style.OK); } private void saveFile(Uri uri) { diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java index 040c26aab..30dfd8dfd 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java @@ -41,6 +41,7 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { // This is a resource, set AFTER it has been verified LinkedCookieResource mVerifiedResource = null; + private ViewAnimator mVerifyButtonAnimator; @Override public void onCreate(Bundle savedInstanceState) { @@ -69,9 +70,10 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { } }); - mVerifyImage = (ImageView) view.findViewById(R.id.verify_image); mVerifyAnimator = (ViewAnimator) view.findViewById(R.id.verify_progress); + mVerifyImage = (ImageView) view.findViewById(R.id.verify_image); mVerifyStatus = (TextView) view.findViewById(R.id.verify_status); + mVerifyButtonAnimator = (ViewAnimator) view.findViewById(R.id.verify_buttons); view.findViewById(R.id.button_verify).setOnClickListener(new OnClickListener() { @Override @@ -80,6 +82,13 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { } }); + view.findViewById(R.id.button_retry).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + proofVerify(); + } + }); + setVerifyProgress(false, null); mVerifyStatus.setText(R.string.linked_verify_pending); @@ -91,20 +100,30 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { private void setVerifyProgress(boolean on, Boolean success) { if (success == null) { mVerifyStatus.setText(R.string.linked_verifying); + displayButton(on ? 2 : 0); } else if (success) { mVerifyStatus.setText(R.string.linked_verify_success); mVerifyImage.setImageResource(R.drawable.status_signature_verified_cutout_24dp); mVerifyImage.setColorFilter(getResources().getColor(R.color.android_green_dark), PorterDuff.Mode.SRC_IN); + displayButton(2); } else { mVerifyStatus.setText(R.string.linked_verify_error); mVerifyImage.setImageResource(R.drawable.status_signature_unknown_cutout_24dp); mVerifyImage.setColorFilter(getResources().getColor(R.color.android_red_dark), PorterDuff.Mode.SRC_IN); + displayButton(1); } mVerifyAnimator.setDisplayedChild(on ? 1 : 0); } + public void displayButton(int button) { + if (mVerifyButtonAnimator.getDisplayedChild() == button) { + return; + } + mVerifyButtonAnimator.setDisplayedChild(button); + } + protected void proofVerify() { setVerifyProgress(true, null); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java index f8322d3c4..2de9b54c9 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java @@ -34,8 +34,6 @@ public class LinkedIdCreateTwitterStep2Fragment extends LinkedIdCreateFinalFragm public static final String ARG_HANDLE = "handle"; - EditText mEditTweetPreview; - String mResourceHandle; String mResourceString; @@ -66,9 +64,6 @@ public class LinkedIdCreateTwitterStep2Fragment extends LinkedIdCreateFinalFragm public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View view = super.onCreateView(inflater, container, savedInstanceState); - mEditTweetPreview = (EditText) view.findViewById(R.id.linked_create_twitter_preview); - mEditTweetPreview.setText(mResourceString); - view.findViewById(R.id.button_send).setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { -- cgit v1.2.3 From ba7d8a58673d55660bc7faf68970229f17458514 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Sat, 14 Mar 2015 23:10:58 +0100 Subject: show certificates for secret keys differently --- .../keychain/ui/linked/LinkedIdViewFragment.java | 41 +++++++++++++++------- 1 file changed, 28 insertions(+), 13 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index 9501e454c..1cec12b26 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -62,13 +62,13 @@ public class LinkedIdViewFragment extends Fragment implements private static final String ARG_DATA_URI = "data_uri"; private static final String ARG_LID_RANK = "rank"; - private static final String ARG_SHOWCERT = "verified"; + private static final String ARG_IS_SECRET = "verified"; private static final String ARG_FINGERPRINT = "fingerprint"; private static final int LOADER_ID_LINKED_ID = 1; private RawLinkedIdentity mLinkedId; private LinkedCookieResource mLinkedResource; - private boolean mShowCert; + private boolean mIsSecret; private Context mContext; private byte[] mFingerprint; @@ -81,13 +81,13 @@ public class LinkedIdViewFragment extends Fragment implements private OnIdentityLoadedListener mIdLoadedListener; public static LinkedIdViewFragment newInstance(Uri dataUri, int rank, - boolean showCertified, byte[] fingerprint) throws IOException { + boolean isSecret, byte[] fingerprint) throws IOException { LinkedIdViewFragment frag = new LinkedIdViewFragment(); Bundle args = new Bundle(); args.putParcelable(ARG_DATA_URI, dataUri); args.putInt(ARG_LID_RANK, rank); - args.putBoolean(ARG_SHOWCERT, showCertified); + args.putBoolean(ARG_IS_SECRET, isSecret); args.putByteArray(ARG_FINGERPRINT, fingerprint); frag.setArguments(args); @@ -102,7 +102,7 @@ public class LinkedIdViewFragment extends Fragment implements mDataUri = args.getParcelable(ARG_DATA_URI); mLidRank = args.getInt(ARG_LID_RANK); - mShowCert = args.getBoolean(ARG_SHOWCERT); + mIsSecret = args.getBoolean(ARG_IS_SECRET); mFingerprint = args.getByteArray(ARG_FINGERPRINT); mContext = getActivity(); @@ -184,7 +184,7 @@ public class LinkedIdViewFragment extends Fragment implements mLinkedResource = (LinkedCookieResource) res; } - if (mShowCert) { + if (!mIsSecret) { mViewHolder.mLinkedIdHolder.vVerified.setVisibility(View.VISIBLE); switch (certStatus) { @@ -276,7 +276,7 @@ public class LinkedIdViewFragment extends Fragment implements VERIFYING, VERIFY_OK, VERIFY_ERROR, CERTIFYING } - void setVerifyingState(VerifyState state) { + void setVerifyingState(VerifyState state, boolean isSecret) { switch (state) { case VERIFYING: vProgress.setDisplayedChild(0); @@ -285,10 +285,15 @@ public class LinkedIdViewFragment extends Fragment implements break; case VERIFY_OK: - showButton(2); vText.setText("Ok"); vProgress.setDisplayedChild(1); - vKeySpinner.setVisibility(View.VISIBLE); + if (!isSecret) { + showButton(2); + vKeySpinner.setVisibility(View.VISIBLE); + } else { + showButton(1); + vKeySpinner.setVisibility(View.GONE); + } break; case VERIFY_ERROR: @@ -411,6 +416,7 @@ public class LinkedIdViewFragment extends Fragment implements { Bundle args = new Bundle(); args.putParcelable(CertListWidget.ARG_URI, Certs.buildLinkedIdCertsUri(mDataUri, mLidRank)); + args.putBoolean(CertListWidget.ARG_IS_SECRET, mIsSecret); getLoaderManager().initLoader(CertListWidget.LOADER_ID_LINKED_CERTS, args, mViewHolder.vLinkedCerts); } @@ -428,7 +434,7 @@ public class LinkedIdViewFragment extends Fragment implements setShowVerifying(true); mViewHolder.vKeySpinner.setVisibility(View.GONE); - mViewHolder.setVerifyingState(VerifyState.VERIFYING); + mViewHolder.setVerifyingState(VerifyState.VERIFYING, mIsSecret); mInProgress = new AsyncTask() { @Override @@ -453,9 +459,9 @@ public class LinkedIdViewFragment extends Fragment implements return; } if (result.success()) { - mViewHolder.setVerifyingState(VerifyState.VERIFY_OK); + mViewHolder.setVerifyingState(VerifyState.VERIFY_OK, mIsSecret); } else { - mViewHolder.setVerifyingState(VerifyState.VERIFY_ERROR); + mViewHolder.setVerifyingState(VerifyState.VERIFY_ERROR, mIsSecret); } mInProgress = null; } @@ -464,6 +470,11 @@ public class LinkedIdViewFragment extends Fragment implements } private void initiateCertifying() { + + if (mIsSecret) { + return; + } + // get the user's passphrase for this key (if required) String passphrase; long certifyKeyId = mViewHolder.vKeySpinner.getSelectedItemId(); @@ -509,7 +520,11 @@ public class LinkedIdViewFragment extends Fragment implements private void certifyResource(long certifyKeyId, String passphrase) { - mViewHolder.setVerifyingState(VerifyState.CERTIFYING); + if (mIsSecret) { + return; + } + + mViewHolder.setVerifyingState(VerifyState.CERTIFYING, mIsSecret); Bundle data = new Bundle(); { -- cgit v1.2.3 From 538be96e61f5b6c2c39b02ed2f1550a1a6a9a2c9 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Sun, 15 Mar 2015 21:41:04 +0100 Subject: work on certification ui --- .../keychain/ui/linked/LinkedIdViewFragment.java | 30 ++++++++++++++-------- 1 file changed, 19 insertions(+), 11 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index c39e40761..502abe8e6 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -7,6 +7,7 @@ import android.app.Activity; import android.content.Context; import android.content.Intent; import android.database.Cursor; +import android.graphics.PorterDuff; import android.net.Uri; import android.os.AsyncTask; import android.os.Bundle; @@ -23,6 +24,7 @@ import android.view.LayoutInflater; import android.view.View; import android.view.View.OnClickListener; import android.view.ViewGroup; +import android.widget.ImageView; import android.widget.TextView; import android.widget.ViewAnimator; @@ -240,6 +242,7 @@ public class LinkedIdViewFragment extends Fragment implements static class ViewHolder { private final View vButtonView; private final ViewAnimator vVerifyingContainer; + private final ViewAnimator vItemCertified; LinkedIdsAdapter.ViewHolder mLinkedIdHolder; private ViewAnimator vButtonSwitcher; @@ -267,6 +270,7 @@ public class LinkedIdViewFragment extends Fragment implements vButtonView = root.findViewById(R.id.button_view); vVerifyingContainer = (ViewAnimator) root.findViewById(R.id.linked_verify_container); + vItemCertified = (ViewAnimator) root.findViewById(R.id.linked_id_certified); vProgress = (ViewAnimator) root.findViewById(R.id.linked_cert_progress); vText = (TextView) root.findViewById(R.id.linked_cert_text); @@ -285,7 +289,6 @@ public class LinkedIdViewFragment extends Fragment implements break; case VERIFY_OK: - vText.setText("Ok"); vProgress.setDisplayedChild(1); if (!isSecret) { showButton(2); @@ -315,7 +318,9 @@ public class LinkedIdViewFragment extends Fragment implements if (vVerifyingContainer.getDisplayedChild() == (show ? 1 : 0)) { return; } + vVerifyingContainer.setDisplayedChild(show ? 1 : 0); + vItemCertified.setDisplayedChild(show ? 1 : 0); } void showButton(int which) { @@ -386,6 +391,15 @@ public class LinkedIdViewFragment extends Fragment implements mViewHolder = new ViewHolder(root); root.setTag(mViewHolder); + ((ImageView) root.findViewById(R.id.status_icon_verified)) + .setColorFilter(mContext.getResources().getColor(R.color.android_green_light), + PorterDuff.Mode.SRC_IN); + ((ImageView) root.findViewById(R.id.status_icon_invalid)) + .setColorFilter(mContext.getResources().getColor(R.color.android_red_light), + PorterDuff.Mode.SRC_IN); + + + mViewHolder.vButtonBack.setClickable(true); mViewHolder.vButtonBack.findViewById(R.id.back_button).setOnClickListener(new OnClickListener() { @Override @@ -459,9 +473,11 @@ public class LinkedIdViewFragment extends Fragment implements return; } if (result.success()) { + mViewHolder.vText.setText(mLinkedResource.getVerifiedText()); mViewHolder.setVerifyingState(VerifyState.VERIFY_OK, mIsSecret); } else { mViewHolder.setVerifyingState(VerifyState.VERIFY_ERROR, mIsSecret); + result.createNotify(getActivity()).show(); } mInProgress = null; } @@ -524,7 +540,7 @@ public class LinkedIdViewFragment extends Fragment implements return; } - mViewHolder.setVerifyingState(VerifyState.CERTIFYING, mIsSecret); + mViewHolder.setVerifyingState(VerifyState.CERTIFYING, false); Bundle data = new Bundle(); { @@ -557,19 +573,11 @@ public class LinkedIdViewFragment extends Fragment implements Bundle data = message.getData(); - if (message.arg1 == MessageStatus.UPDATE_PROGRESS.ordinal()) { - if (data.containsKey(DATA_MESSAGE)) { - mViewHolder.vText.setText(data.getString(DATA_MESSAGE)); - } else if (data.containsKey(DATA_MESSAGE_ID)) { - mViewHolder.vText.setText(data.getString(DATA_MESSAGE_ID)); - } - return; - } - if (message.arg1 == MessageStatus.OKAY.ordinal()) { CertifyResult result = data.getParcelable(CertifyResult.EXTRA_RESULT); result.createNotify(getActivity()).show(); } + } }; -- cgit v1.2.3 From b25371fc1bd604dd15f3f42bda7227e3f84d4515 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Tue, 24 Mar 2015 02:30:39 +0100 Subject: support github resource (re) --- .../linked/LinkedIdCreateGithubStep1Fragment.java | 129 +++++++++++++++++++++ .../linked/LinkedIdCreateGithubStep2Fragment.java | 111 ++++++++++++++++++ .../keychain/ui/linked/LinkedIdSelectFragment.java | 12 ++ 3 files changed, 252 insertions(+) create mode 100644 OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep1Fragment.java create mode 100644 OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep2Fragment.java (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep1Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep1Fragment.java new file mode 100644 index 000000000..86a514fa9 --- /dev/null +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep1Fragment.java @@ -0,0 +1,129 @@ +/* + * Copyright (C) 2014 Dominik Schürmann + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package org.sufficientlysecure.keychain.ui.linked; + + +import java.io.IOException; +import java.net.HttpURLConnection; +import java.net.URL; + +import android.os.AsyncTask; +import android.os.Bundle; +import android.support.v4.app.Fragment; +import android.view.LayoutInflater; +import android.view.View; +import android.view.View.OnClickListener; +import android.view.ViewGroup; +import android.widget.EditText; + +import org.sufficientlysecure.keychain.R; +import org.sufficientlysecure.keychain.ui.util.Notify; + + +public class LinkedIdCreateGithubStep1Fragment extends Fragment { + + LinkedIdWizard mLinkedIdWizard; + + EditText mEditHandle; + + public static LinkedIdCreateGithubStep1Fragment newInstance() { + LinkedIdCreateGithubStep1Fragment frag = new LinkedIdCreateGithubStep1Fragment(); + + Bundle args = new Bundle(); + frag.setArguments(args); + + return frag; + } + + @Override + public void onActivityCreated(Bundle savedInstanceState) { + super.onActivityCreated(savedInstanceState); + + mLinkedIdWizard = (LinkedIdWizard) getActivity(); + + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + final View view = inflater.inflate(R.layout.linked_create_github_fragment_step1, container, false); + + view.findViewById(R.id.next_button).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + + final String handle = mEditHandle.getText().toString(); + + new AsyncTask() { + + @Override + protected Boolean doInBackground(Void... params) { + return true; // return checkHandle(handle); + } + + @Override + protected void onPostExecute(Boolean result) { + super.onPostExecute(result); + + if (result == null) { + Notify.showNotify(getActivity(), + "Connection error while checking username!", Notify.Style.ERROR); + return; + } + + if (!result) { + Notify.showNotify(getActivity(), + "This handle does not exist on Github!", Notify.Style.ERROR); + return; + } + + LinkedIdCreateGithubStep2Fragment frag = + LinkedIdCreateGithubStep2Fragment.newInstance(handle); + + mLinkedIdWizard.loadFragment(null, frag, LinkedIdWizard.FRAG_ACTION_TO_RIGHT); + } + }.execute(); + + } + }); + + view.findViewById(R.id.back_button).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + mLinkedIdWizard.loadFragment(null, null, LinkedIdWizard.FRAG_ACTION_TO_LEFT); + } + }); + + mEditHandle = (EditText) view.findViewById(R.id.linked_create_github_handle); + mEditHandle.setText("Valodim"); + + return view; + } + + private static Boolean checkHandle(String handle) { + try { + HttpURLConnection nection = + (HttpURLConnection) new URL("https://api.github.com/" + handle).openConnection(); + nection.setRequestMethod("HEAD"); + return nection.getResponseCode() == 200; + } catch (IOException e) { + e.printStackTrace(); + return null; + } + } + +} diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep2Fragment.java new file mode 100644 index 000000000..05bdf89a4 --- /dev/null +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep2Fragment.java @@ -0,0 +1,111 @@ +/* + * Copyright (C) 2014 Dominik Schürmann + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package org.sufficientlysecure.keychain.ui.linked; + +import android.content.Intent; +import android.net.Uri; +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.View.OnClickListener; +import android.view.ViewGroup; + +import org.sufficientlysecure.keychain.R; +import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; +import org.sufficientlysecure.keychain.pgp.linked.resources.GithubResource; + + +public class LinkedIdCreateGithubStep2Fragment extends LinkedIdCreateFinalFragment { + + public static final String ARG_HANDLE = "handle"; + + String mResourceHandle; + String mResourceString; + + public static LinkedIdCreateGithubStep2Fragment newInstance + (String handle) { + + LinkedIdCreateGithubStep2Fragment frag = new LinkedIdCreateGithubStep2Fragment(); + + Bundle args = new Bundle(); + args.putString(ARG_HANDLE, handle); + frag.setArguments(args); + + return frag; + } + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + + mResourceString = + GithubResource.generate(getActivity(), mLinkedIdWizard.mFingerprint); + + mResourceHandle = getArguments().getString(ARG_HANDLE); + + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + View view = super.onCreateView(inflater, container, savedInstanceState); + + view.findViewById(R.id.button_send).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + proofSend(); + } + }); + + view.findViewById(R.id.button_share).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + proofShare(); + } + }); + + return view; + } + + @Override + LinkedCookieResource getResource() { + return GithubResource.searchInGithubStream(mResourceHandle, mResourceString); + } + + @Override + protected View newView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + return inflater.inflate(R.layout.linked_create_github_fragment_step2, container, false); + } + + private void proofShare() { + Intent sendIntent = new Intent(); + sendIntent.setAction(Intent.ACTION_SEND); + sendIntent.putExtra(Intent.EXTRA_TEXT, mResourceString); + sendIntent.setType("text/plain"); + startActivity(sendIntent); + } + + private void proofSend() { + Uri.Builder builder = Uri.parse("https://gist.github.com/").buildUpon(); + builder.appendQueryParameter("text", mResourceString); + Uri uri = builder.build(); + + Intent intent = new Intent(Intent.ACTION_VIEW, uri); + getActivity().startActivity(intent); + } + +} diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdSelectFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdSelectFragment.java index abe7dbaf1..8249f0bb6 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdSelectFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdSelectFragment.java @@ -78,6 +78,18 @@ public class LinkedIdSelectFragment extends Fragment { } }); + view.findViewById(R.id.linked_create_github_button) + .setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + LinkedIdCreateGithubStep1Fragment frag = + LinkedIdCreateGithubStep1Fragment.newInstance(); + + mLinkedIdWizard.loadFragment(null, frag, LinkedIdWizard.FRAG_ACTION_TO_RIGHT); + } + }); + + return view; } -- cgit v1.2.3 From e573cd774a4a41234c229d9c49ef7a5656445f93 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Tue, 24 Mar 2015 16:41:01 +0100 Subject: work on cookie scanning during creation --- .../ui/linked/LinkedIdCreateDnsStep2Fragment.java | 3 ++- .../ui/linked/LinkedIdCreateFinalFragment.java | 20 ++++++++++++++------ .../ui/linked/LinkedIdCreateGithubStep2Fragment.java | 5 +++-- .../ui/linked/LinkedIdCreateHttpsStep2Fragment.java | 3 ++- .../linked/LinkedIdCreateTwitterStep2Fragment.java | 5 +++-- .../keychain/ui/linked/LinkedIdViewFragment.java | 2 +- 6 files changed, 25 insertions(+), 13 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java index c0e2fd29c..e8668dc90 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java @@ -31,6 +31,7 @@ import android.widget.TextView; import org.sufficientlysecure.keychain.Constants; import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.compatibility.ClipboardReflection; +import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog; import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; import org.sufficientlysecure.keychain.pgp.linked.resources.DnsResource; import org.sufficientlysecure.keychain.ui.util.Notify; @@ -104,7 +105,7 @@ public class LinkedIdCreateDnsStep2Fragment extends LinkedIdCreateFinalFragment } @Override - LinkedCookieResource getResource() { + LinkedCookieResource getResource(OperationLog log) { return DnsResource.createNew(mResourceDomain); } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java index 99e770857..4f10102ae 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java @@ -20,6 +20,7 @@ import android.widget.ViewAnimator; import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.operations.results.LinkedVerifyResult; import org.sufficientlysecure.keychain.operations.results.OperationResult; +import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog; import org.sufficientlysecure.keychain.pgp.WrappedUserAttribute; import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; @@ -28,6 +29,8 @@ import org.sufficientlysecure.keychain.service.KeychainIntentServiceHandler; import org.sufficientlysecure.keychain.service.SaveKeyringParcel; import org.sufficientlysecure.keychain.ui.PassphraseDialogActivity; import org.sufficientlysecure.keychain.ui.util.Notify; +import org.sufficientlysecure.keychain.util.Passphrase; + public abstract class LinkedIdCreateFinalFragment extends Fragment { @@ -95,7 +98,7 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { return view; } - abstract LinkedCookieResource getResource(); + abstract LinkedCookieResource getResource(OperationLog log); private void setVerifyProgress(boolean on, Boolean success) { if (success == null) { @@ -133,7 +136,12 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { protected LinkedVerifyResult doInBackground(Void... params) { long timer = System.currentTimeMillis(); - LinkedCookieResource resource = getResource(); + OperationLog log = new OperationLog(); + LinkedCookieResource resource = getResource(log); + if (resource == null) { + return new LinkedVerifyResult(LinkedVerifyResult.RESULT_ERROR, log); + } + LinkedVerifyResult result = resource.verify(mLinkedIdWizard.mFingerprint); // ux flow: this operation should take at last a second @@ -178,7 +186,7 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { } - private void certifyLinkedIdentity (String passphrase) { + private void certifyLinkedIdentity (Passphrase passphrase) { KeychainIntentServiceHandler saveHandler = new KeychainIntentServiceHandler( getActivity(), getString(R.string.progress_saving), @@ -227,7 +235,7 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { // fill values for this action Bundle data = new Bundle(); - data.putString(KeychainIntentService.EDIT_KEYRING_PASSPHRASE, passphrase); + data.putParcelable(KeychainIntentService.EDIT_KEYRING_PASSPHRASE, passphrase); data.putParcelable(KeychainIntentService.EDIT_KEYRING_PARCEL, skp); intent.putExtra(KeychainIntentService.EXTRA_DATA, data); @@ -249,8 +257,8 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { switch (requestCode) { case REQUEST_CODE_PASSPHRASE: if (resultCode == Activity.RESULT_OK && data != null) { - String passphrase = - data.getStringExtra(PassphraseDialogActivity.MESSAGE_DATA_PASSPHRASE); + Passphrase passphrase = + data.getParcelableExtra(PassphraseDialogActivity.MESSAGE_DATA_PASSPHRASE); certifyLinkedIdentity(passphrase); } break; diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep2Fragment.java index 05bdf89a4..cc1052b1f 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep2Fragment.java @@ -26,6 +26,7 @@ import android.view.View.OnClickListener; import android.view.ViewGroup; import org.sufficientlysecure.keychain.R; +import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog; import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; import org.sufficientlysecure.keychain.pgp.linked.resources.GithubResource; @@ -82,8 +83,8 @@ public class LinkedIdCreateGithubStep2Fragment extends LinkedIdCreateFinalFragme } @Override - LinkedCookieResource getResource() { - return GithubResource.searchInGithubStream(mResourceHandle, mResourceString); + LinkedCookieResource getResource(OperationLog log) { + return GithubResource.searchInGithubStream(mResourceHandle, mResourceString, log); } @Override diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java index 5559c0daf..6bb555105 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java @@ -30,6 +30,7 @@ import android.widget.EditText; import org.sufficientlysecure.keychain.Constants; import org.sufficientlysecure.keychain.R; +import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog; import org.sufficientlysecure.keychain.pgp.linked.resources.GenericHttpsResource; import org.sufficientlysecure.keychain.ui.util.Notify; import org.sufficientlysecure.keychain.ui.util.Notify.Style; @@ -66,7 +67,7 @@ public class LinkedIdCreateHttpsStep2Fragment extends LinkedIdCreateFinalFragmen } @Override - GenericHttpsResource getResource() { + GenericHttpsResource getResource(OperationLog log) { return GenericHttpsResource.createNew(mResourceUri); } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java index 2de9b54c9..66e86f7d4 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java @@ -27,6 +27,7 @@ import android.view.ViewGroup; import android.widget.EditText; import org.sufficientlysecure.keychain.R; +import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog; import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; import org.sufficientlysecure.keychain.pgp.linked.resources.TwitterResource; @@ -82,8 +83,8 @@ public class LinkedIdCreateTwitterStep2Fragment extends LinkedIdCreateFinalFragm } @Override - LinkedCookieResource getResource() { - return TwitterResource.searchInTwitterStream(mResourceHandle, mResourceString); + LinkedCookieResource getResource(OperationLog log) { + return TwitterResource.searchInTwitterStream(mResourceHandle, mResourceString, log); } @Override diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index 41d0178a3..4a3c6f4d0 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -133,7 +133,7 @@ public class LinkedIdViewFragment extends Fragment implements case LOADER_ID_LINKED_ID: if (!cursor.moveToFirst()) { - Notify.createNotify(getActivity(), "Error loading identity!", + Notify.create(getActivity(), "Error loading identity!", Notify.LENGTH_LONG, Style.ERROR).show(); finishFragment(); break; -- cgit v1.2.3 From 3edf47c5decdc547724bc84628ddfa25bf8ae53a Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Tue, 24 Mar 2015 19:47:54 +0100 Subject: secret/public distinction in LinkedIdView --- .../keychain/ui/linked/LinkedIdViewFragment.java | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index 4a3c6f4d0..e0db0174e 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -315,13 +315,13 @@ public class LinkedIdViewFragment extends Fragment implements } } - void showVerifyingContainer(boolean show) { + void showVerifyingContainer(boolean show, boolean isSecret) { if (vVerifyingContainer.getDisplayedChild() == (show ? 1 : 0)) { return; } vVerifyingContainer.setDisplayedChild(show ? 1 : 0); - vItemCertified.setDisplayedChild(show ? 1 : 0); + vItemCertified.setDisplayedChild(show && !isSecret ? 1 : 0); } void showButton(int which) { @@ -363,7 +363,7 @@ public class LinkedIdViewFragment extends Fragment implements mViewHolder.showButton(0); mViewHolder.vKeySpinner.setVisibility(View.GONE); - mViewHolder.showVerifyingContainer(false); + mViewHolder.showVerifyingContainer(false, mIsSecret); return; } @@ -376,7 +376,7 @@ public class LinkedIdViewFragment extends Fragment implements manager.beginTransaction().addToBackStack("verification").commit(); manager.executePendingTransactions(); manager.addOnBackStackChangedListener(this); - mViewHolder.showVerifyingContainer(true); + mViewHolder.showVerifyingContainer(true, mIsSecret); } @@ -474,7 +474,7 @@ public class LinkedIdViewFragment extends Fragment implements return; } if (result.success()) { - mViewHolder.vText.setText(mLinkedResource.getVerifiedText()); + mViewHolder.vText.setText(mLinkedResource.getVerifiedText(mIsSecret)); mViewHolder.setVerifyingState(VerifyState.VERIFY_OK, mIsSecret); } else { mViewHolder.setVerifyingState(VerifyState.VERIFY_ERROR, mIsSecret); -- cgit v1.2.3 From aa6d0dd86773eda7d0a5a6855b40c2e1f95e2b45 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Thu, 26 Mar 2015 13:53:43 +0100 Subject: some linked id ui fine tuning --- .../keychain/ui/linked/LinkedIdViewFragment.java | 53 ++++++++++++---------- 1 file changed, 30 insertions(+), 23 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index e0db0174e..aa99a2907 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -25,10 +25,11 @@ import android.view.View; import android.view.View.OnClickListener; import android.view.ViewGroup; import android.widget.ImageView; -import android.widget.TextView; +import android.widget.TextSwitcher; import android.widget.ViewAnimator; import org.sufficientlysecure.keychain.Constants; +import org.sufficientlysecure.keychain.Constants.key; import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.operations.results.CertifyResult; import org.sufficientlysecure.keychain.operations.results.LinkedVerifyResult; @@ -180,16 +181,12 @@ public class LinkedIdViewFragment extends Fragment implements private void loadIdentity(RawLinkedIdentity linkedId, int certStatus) { mLinkedId = linkedId; - setShowVerifying(false); - if (mLinkedId instanceof LinkedIdentity) { LinkedResource res = ((LinkedIdentity) mLinkedId).mResource; mLinkedResource = (LinkedCookieResource) res; } if (!mIsSecret) { - mViewHolder.mLinkedIdHolder.vVerified.setVisibility(View.VISIBLE); - switch (certStatus) { case Certs.VERIFIED_SECRET: KeyFormattingUtils.setStatusImage(mContext, mViewHolder.mLinkedIdHolder.vVerified, @@ -204,12 +201,12 @@ public class LinkedIdViewFragment extends Fragment implements null, State.INVALID, KeyFormattingUtils.DEFAULT_COLOR); break; } - } else { - mViewHolder.mLinkedIdHolder.vVerified.setVisibility(View.GONE); } mViewHolder.mLinkedIdHolder.setData(mContext, mLinkedId); + setShowVerifying(false); + // no resource, nothing further we can do… if (mLinkedResource == null) { mViewHolder.vButtonView.setVisibility(View.GONE); @@ -255,7 +252,7 @@ public class LinkedIdViewFragment extends Fragment implements private final View vButtonBack; private final ViewAnimator vProgress; - private final TextView vText; + private final TextSwitcher vText; ViewHolder(View root) { vLinkedCerts = (CertListWidget) root.findViewById(R.id.linked_id_certs); @@ -274,18 +271,18 @@ public class LinkedIdViewFragment extends Fragment implements vItemCertified = (ViewAnimator) root.findViewById(R.id.linked_id_certified); vProgress = (ViewAnimator) root.findViewById(R.id.linked_cert_progress); - vText = (TextView) root.findViewById(R.id.linked_cert_text); + vText = (TextSwitcher) root.findViewById(R.id.linked_cert_text); } enum VerifyState { VERIFYING, VERIFY_OK, VERIFY_ERROR, CERTIFYING } - void setVerifyingState(VerifyState state, boolean isSecret) { + void setVerifyingState(Context context, VerifyState state, boolean isSecret) { switch (state) { case VERIFYING: vProgress.setDisplayedChild(0); - vText.setText("Verifying…"); + vText.setText(context.getString(R.string.linked_text_verifying)); vKeySpinner.setVisibility(View.GONE); break; @@ -303,25 +300,30 @@ public class LinkedIdViewFragment extends Fragment implements case VERIFY_ERROR: showButton(1); vProgress.setDisplayedChild(2); - vText.setText("Error"); + vText.setText(context.getString(R.string.linked_text_error)); vKeySpinner.setVisibility(View.GONE); break; case CERTIFYING: vProgress.setDisplayedChild(0); - vText.setText("Confirming…"); + vText.setText(context.getString(R.string.linked_text_confirming)); vKeySpinner.setVisibility(View.GONE); break; } } - void showVerifyingContainer(boolean show, boolean isSecret) { + void showVerifyingContainer(Context context, boolean show, boolean isSecret) { if (vVerifyingContainer.getDisplayedChild() == (show ? 1 : 0)) { return; } + vVerifyingContainer.setInAnimation(context, show ? R.anim.fade_in_up : R.anim.fade_in_down); + vVerifyingContainer.setOutAnimation(context, show ? R.anim.fade_out_up : R.anim.fade_out_down); vVerifyingContainer.setDisplayedChild(show ? 1 : 0); - vItemCertified.setDisplayedChild(show && !isSecret ? 1 : 0); + + vItemCertified.setInAnimation(context, show ? R.anim.fade_in_up : R.anim.fade_in_down); + vItemCertified.setOutAnimation(context, show ? R.anim.fade_out_up : R.anim.fade_out_down); + vItemCertified.setDisplayedChild(show || isSecret ? 1 : 0); } void showButton(int which) { @@ -363,7 +365,7 @@ public class LinkedIdViewFragment extends Fragment implements mViewHolder.showButton(0); mViewHolder.vKeySpinner.setVisibility(View.GONE); - mViewHolder.showVerifyingContainer(false, mIsSecret); + mViewHolder.showVerifyingContainer(mContext, false, mIsSecret); return; } @@ -376,7 +378,7 @@ public class LinkedIdViewFragment extends Fragment implements manager.beginTransaction().addToBackStack("verification").commit(); manager.executePendingTransactions(); manager.addOnBackStackChangedListener(this); - mViewHolder.showVerifyingContainer(true, mIsSecret); + mViewHolder.showVerifyingContainer(mContext, true, mIsSecret); } @@ -449,7 +451,7 @@ public class LinkedIdViewFragment extends Fragment implements setShowVerifying(true); mViewHolder.vKeySpinner.setVisibility(View.GONE); - mViewHolder.setVerifyingState(VerifyState.VERIFYING, mIsSecret); + mViewHolder.setVerifyingState(mContext, VerifyState.VERIFYING, mIsSecret); mInProgress = new AsyncTask() { @Override @@ -474,10 +476,10 @@ public class LinkedIdViewFragment extends Fragment implements return; } if (result.success()) { - mViewHolder.vText.setText(mLinkedResource.getVerifiedText(mIsSecret)); - mViewHolder.setVerifyingState(VerifyState.VERIFY_OK, mIsSecret); + mViewHolder.vText.setText(getString(mLinkedResource.getVerifiedText(mIsSecret))); + mViewHolder.setVerifyingState(mContext, VerifyState.VERIFY_OK, mIsSecret); } else { - mViewHolder.setVerifyingState(VerifyState.VERIFY_ERROR, mIsSecret); + mViewHolder.setVerifyingState(mContext, VerifyState.VERIFY_ERROR, mIsSecret); result.createNotify(getActivity()).show(); } mInProgress = null; @@ -493,8 +495,12 @@ public class LinkedIdViewFragment extends Fragment implements } // get the user's passphrase for this key (if required) - Passphrase passphrase; long certifyKeyId = mViewHolder.vKeySpinner.getSelectedItemId(); + if (certifyKeyId == key.none || certifyKeyId == key.symmetric) { + Notify.create(getActivity(), R.string.select_key_to_certify, Style.ERROR).show(); + } + + Passphrase passphrase; try { passphrase = PassphraseCacheService.getCachedPassphrase( getActivity(), certifyKeyId, certifyKeyId); @@ -541,7 +547,7 @@ public class LinkedIdViewFragment extends Fragment implements return; } - mViewHolder.setVerifyingState(VerifyState.CERTIFYING, false); + mViewHolder.setVerifyingState(mContext, VerifyState.CERTIFYING, false); Bundle data = new Bundle(); { @@ -577,6 +583,7 @@ public class LinkedIdViewFragment extends Fragment implements if (message.arg1 == MessageStatus.OKAY.ordinal()) { CertifyResult result = data.getParcelable(CertifyResult.EXTRA_RESULT); result.createNotify(getActivity()).show(); + // no need to do anything else, we will get a loader refresh! } } -- cgit v1.2.3 From dc8b04a79333d13f3e9903757502521348ccec57 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Thu, 26 Mar 2015 16:30:49 +0100 Subject: more linked id ui fine tuning --- .../org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java | 2 ++ 1 file changed, 2 insertions(+) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index aa99a2907..2efafc086 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -478,6 +478,7 @@ public class LinkedIdViewFragment extends Fragment implements if (result.success()) { mViewHolder.vText.setText(getString(mLinkedResource.getVerifiedText(mIsSecret))); mViewHolder.setVerifyingState(mContext, VerifyState.VERIFY_OK, mIsSecret); + } else { mViewHolder.setVerifyingState(mContext, VerifyState.VERIFY_ERROR, mIsSecret); result.createNotify(getActivity()).show(); @@ -498,6 +499,7 @@ public class LinkedIdViewFragment extends Fragment implements long certifyKeyId = mViewHolder.vKeySpinner.getSelectedItemId(); if (certifyKeyId == key.none || certifyKeyId == key.symmetric) { Notify.create(getActivity(), R.string.select_key_to_certify, Style.ERROR).show(); + return; } Passphrase passphrase; -- cgit v1.2.3 From ab5a7d409450d6e7451ec8ea62ca091df83e2933 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Thu, 26 Mar 2015 17:52:18 +0100 Subject: more (subtle) ui work --- .../keychain/ui/linked/LinkedIdViewFragment.java | 29 ++++++++++++++++------ 1 file changed, 21 insertions(+), 8 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index 2efafc086..5c1389573 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -3,13 +3,18 @@ package org.sufficientlysecure.keychain.ui.linked; import java.io.IOException; import java.util.Arrays; +import android.animation.Animator; +import android.animation.Animator.AnimatorListener; +import android.animation.ObjectAnimator; import android.app.Activity; import android.content.Context; import android.content.Intent; import android.database.Cursor; import android.graphics.PorterDuff; +import android.graphics.drawable.Drawable; import android.net.Uri; import android.os.AsyncTask; +import android.os.Build; import android.os.Bundle; import android.os.Handler; import android.os.Message; @@ -53,6 +58,7 @@ import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils; import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils.State; import org.sufficientlysecure.keychain.ui.util.Notify; import org.sufficientlysecure.keychain.ui.util.Notify.Style; +import org.sufficientlysecure.keychain.ui.util.SubtleAttentionSeeker; import org.sufficientlysecure.keychain.ui.widget.CertListWidget; import org.sufficientlysecure.keychain.ui.widget.CertifyKeySpinner; import org.sufficientlysecure.keychain.util.Log; @@ -241,6 +247,7 @@ public class LinkedIdViewFragment extends Fragment implements private final View vButtonView; private final ViewAnimator vVerifyingContainer; private final ViewAnimator vItemCertified; + private final View vKeySpinnerContainer; LinkedIdsAdapter.ViewHolder mLinkedIdHolder; private ViewAnimator vButtonSwitcher; @@ -257,6 +264,7 @@ public class LinkedIdViewFragment extends Fragment implements ViewHolder(View root) { vLinkedCerts = (CertListWidget) root.findViewById(R.id.linked_id_certs); vKeySpinner = (CertifyKeySpinner) root.findViewById(R.id.cert_key_spinner); + vKeySpinnerContainer = root.findViewById(R.id.cert_key_spincontainer); vButtonSwitcher = (ViewAnimator) root.findViewById(R.id.button_animator); mLinkedIdHolder = new LinkedIdsAdapter.ViewHolder(root); @@ -283,17 +291,17 @@ public class LinkedIdViewFragment extends Fragment implements case VERIFYING: vProgress.setDisplayedChild(0); vText.setText(context.getString(R.string.linked_text_verifying)); - vKeySpinner.setVisibility(View.GONE); + vKeySpinnerContainer.setVisibility(View.GONE); break; case VERIFY_OK: vProgress.setDisplayedChild(1); if (!isSecret) { showButton(2); - vKeySpinner.setVisibility(View.VISIBLE); + vKeySpinnerContainer.setVisibility(View.VISIBLE); } else { showButton(1); - vKeySpinner.setVisibility(View.GONE); + vKeySpinnerContainer.setVisibility(View.GONE); } break; @@ -301,13 +309,13 @@ public class LinkedIdViewFragment extends Fragment implements showButton(1); vProgress.setDisplayedChild(2); vText.setText(context.getString(R.string.linked_text_error)); - vKeySpinner.setVisibility(View.GONE); + vKeySpinnerContainer.setVisibility(View.GONE); break; case CERTIFYING: vProgress.setDisplayedChild(0); vText.setText(context.getString(R.string.linked_text_confirming)); - vKeySpinner.setVisibility(View.GONE); + vKeySpinnerContainer.setVisibility(View.GONE); break; } } @@ -364,7 +372,7 @@ public class LinkedIdViewFragment extends Fragment implements mVerificationState = false; mViewHolder.showButton(0); - mViewHolder.vKeySpinner.setVisibility(View.GONE); + mViewHolder.vKeySpinnerContainer.setVisibility(View.GONE); mViewHolder.showVerifyingContainer(mContext, false, mIsSecret); return; } @@ -450,7 +458,7 @@ public class LinkedIdViewFragment extends Fragment implements setShowVerifying(true); - mViewHolder.vKeySpinner.setVisibility(View.GONE); + mViewHolder.vKeySpinnerContainer.setVisibility(View.GONE); mViewHolder.setVerifyingState(mContext, VerifyState.VERIFYING, mIsSecret); mInProgress = new AsyncTask() { @@ -478,7 +486,9 @@ public class LinkedIdViewFragment extends Fragment implements if (result.success()) { mViewHolder.vText.setText(getString(mLinkedResource.getVerifiedText(mIsSecret))); mViewHolder.setVerifyingState(mContext, VerifyState.VERIFY_OK, mIsSecret); - + ObjectAnimator anim = SubtleAttentionSeeker.tada(mViewHolder.vButtonConfirm, 0.6f, 1000); + anim.setStartDelay(800); + anim.start(); } else { mViewHolder.setVerifyingState(mContext, VerifyState.VERIFY_ERROR, mIsSecret); result.createNotify(getActivity()).show(); @@ -498,6 +508,9 @@ public class LinkedIdViewFragment extends Fragment implements // get the user's passphrase for this key (if required) long certifyKeyId = mViewHolder.vKeySpinner.getSelectedItemId(); if (certifyKeyId == key.none || certifyKeyId == key.symmetric) { + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) { + SubtleAttentionSeeker.tint(mViewHolder.vKeySpinnerContainer, 600).start(); + } Notify.create(getActivity(), R.string.select_key_to_certify, Style.ERROR).show(); return; } -- cgit v1.2.3 From 01c444d63788b78781132ef5cc9998b0b4352e71 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Sun, 29 Mar 2015 23:38:01 +0200 Subject: even more linked id ui work --- .../keychain/ui/linked/LinkedIdViewFragment.java | 39 ++++++++++------------ 1 file changed, 17 insertions(+), 22 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index 5c1389573..3a83939e7 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -3,15 +3,12 @@ package org.sufficientlysecure.keychain.ui.linked; import java.io.IOException; import java.util.Arrays; -import android.animation.Animator; -import android.animation.Animator.AnimatorListener; import android.animation.ObjectAnimator; import android.app.Activity; import android.content.Context; import android.content.Intent; import android.database.Cursor; import android.graphics.PorterDuff; -import android.graphics.drawable.Drawable; import android.net.Uri; import android.os.AsyncTask; import android.os.Build; @@ -139,10 +136,14 @@ public class LinkedIdViewFragment extends Fragment implements switch (loader.getId()) { case LOADER_ID_LINKED_ID: + // Nothing to load means break if we are *expected* to load if (!cursor.moveToFirst()) { - Notify.create(getActivity(), "Error loading identity!", - Notify.LENGTH_LONG, Style.ERROR).show(); - finishFragment(); + if (mIdLoadedListener != null) { + Notify.create(getActivity(), "Error loading identity!", + Notify.LENGTH_LONG, Style.ERROR).show(); + finishFragment(); + } + // Or just ignore, this is probably some intermediate state during certify break; } @@ -171,9 +172,14 @@ public class LinkedIdViewFragment extends Fragment implements } public void finishFragment() { - FragmentManager manager = getFragmentManager(); - manager.removeOnBackStackChangedListener(this); - manager.popBackStack("linked_id", FragmentManager.POP_BACK_STACK_INCLUSIVE); + new Handler().post(new Runnable() { + @Override + public void run() { + FragmentManager manager = getFragmentManager(); + manager.removeOnBackStackChangedListener(LinkedIdViewFragment.this); + manager.popBackStack("linked_id", FragmentManager.POP_BACK_STACK_INCLUSIVE); + } + }); } public interface OnIdentityLoadedListener { @@ -256,7 +262,6 @@ public class LinkedIdViewFragment extends Fragment implements private final View vButtonVerify; private final View vButtonRetry; private final View vButtonConfirm; - private final View vButtonBack; private final ViewAnimator vProgress; private final TextSwitcher vText; @@ -269,7 +274,6 @@ public class LinkedIdViewFragment extends Fragment implements mLinkedIdHolder = new LinkedIdsAdapter.ViewHolder(root); - vButtonBack = root.findViewById(R.id.back_button); vButtonVerify = root.findViewById(R.id.button_verify); vButtonRetry = root.findViewById(R.id.button_retry); vButtonConfirm = root.findViewById(R.id.button_confirm); @@ -409,16 +413,6 @@ public class LinkedIdViewFragment extends Fragment implements .setColorFilter(mContext.getResources().getColor(R.color.android_red_light), PorterDuff.Mode.SRC_IN); - - - mViewHolder.vButtonBack.setClickable(true); - mViewHolder.vButtonBack.findViewById(R.id.back_button).setOnClickListener(new OnClickListener() { - @Override - public void onClick(View v) { - getFragmentManager().popBackStack(); - } - }); - mViewHolder.vButtonVerify.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { @@ -510,8 +504,9 @@ public class LinkedIdViewFragment extends Fragment implements if (certifyKeyId == key.none || certifyKeyId == key.symmetric) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) { SubtleAttentionSeeker.tint(mViewHolder.vKeySpinnerContainer, 600).start(); + } else { + Notify.create(getActivity(), R.string.select_key_to_certify, Style.ERROR).show(); } - Notify.create(getActivity(), R.string.select_key_to_certify, Style.ERROR).show(); return; } -- cgit v1.2.3 From b12aa63cb35e88df66ad424e12586c02217df246 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Fri, 24 Apr 2015 15:44:33 +0200 Subject: use CryptoOperationFragment for linked id fragments, and some warning cleanup --- .../ui/linked/LinkedIdCreateFinalFragment.java | 42 ++++------------ .../keychain/ui/linked/LinkedIdViewFragment.java | 56 ++++++---------------- 2 files changed, 25 insertions(+), 73 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java index 0767aabd2..b98fc6238 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java @@ -1,6 +1,5 @@ package org.sufficientlysecure.keychain.ui.linked; -import android.app.Activity; import android.app.ProgressDialog; import android.content.Intent; import android.graphics.PorterDuff; @@ -8,7 +7,6 @@ import android.os.AsyncTask; import android.os.Bundle; import android.os.Message; import android.os.Messenger; -import android.support.v4.app.Fragment; import android.view.LayoutInflater; import android.view.View; import android.view.View.OnClickListener; @@ -28,14 +26,11 @@ import org.sufficientlysecure.keychain.service.KeychainIntentService; import org.sufficientlysecure.keychain.service.SaveKeyringParcel; import org.sufficientlysecure.keychain.service.ServiceProgressHandler; import org.sufficientlysecure.keychain.service.input.CryptoInputParcel; -import org.sufficientlysecure.keychain.ui.PassphraseDialogActivity; +import org.sufficientlysecure.keychain.ui.base.CryptoOperationFragment; import org.sufficientlysecure.keychain.ui.dialog.ProgressDialogFragment.ServiceType; import org.sufficientlysecure.keychain.ui.util.Notify; -import org.sufficientlysecure.keychain.util.Passphrase; -public abstract class LinkedIdCreateFinalFragment extends Fragment { - - protected static final int REQUEST_CODE_PASSPHRASE = 0x00007008; +public abstract class LinkedIdCreateFinalFragment extends CryptoOperationFragment { protected LinkedIdWizard mLinkedIdWizard; @@ -63,7 +58,7 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { view.findViewById(R.id.next_button).setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { - startCertify(); + cryptoOperation(); } }); @@ -174,29 +169,28 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { } - private void startCertify() { + protected void cryptoOperation(CryptoInputParcel cryptoInput) { if (mVerifiedResource == null) { Notify.create(getActivity(), R.string.linked_need_verify, Notify.Style.ERROR).show(); return; } - Intent intent = new Intent(getActivity(), PassphraseDialogActivity.class); - intent.putExtra(PassphraseDialogActivity.EXTRA_SUBKEY_ID, mLinkedIdWizard.mMasterKeyId); - startActivityForResult(intent, REQUEST_CODE_PASSPHRASE); - - } - - private void certifyLinkedIdentity (CryptoInputParcel cryptoInput) { ServiceProgressHandler saveHandler = new ServiceProgressHandler( getActivity(), getString(R.string.progress_saving), ProgressDialog.STYLE_HORIZONTAL, true, ServiceType.KEYCHAIN_INTENT) { + public void handleMessage(Message message) { // handle messages by standard KeychainIntentServiceHandler first super.handleMessage(message); + // handle pending messages + if (handlePendingMessage(message)) { + return; + } + if (message.arg1 == MessageStatus.OKAY.ordinal()) { // get returned data bundle @@ -252,20 +246,4 @@ public abstract class LinkedIdCreateFinalFragment extends Fragment { } - - @Override - public void onActivityResult(int requestCode, int resultCode, Intent data) { - switch (requestCode) { - case REQUEST_CODE_PASSPHRASE: - if (resultCode == Activity.RESULT_OK && data != null) { - CryptoInputParcel cryptoInput = - data.getParcelableExtra(PassphraseDialogActivity.RESULT_CRYPTO_INPUT); - certifyLinkedIdentity(cryptoInput); - } - break; - default: - super.onActivityResult(requestCode, resultCode, data); - } - } - } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index 1944146dd..152cb8988 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -4,7 +4,6 @@ import java.io.IOException; import java.util.Collections; import android.animation.ObjectAnimator; -import android.app.Activity; import android.content.Context; import android.content.Intent; import android.database.Cursor; @@ -16,7 +15,6 @@ import android.os.Bundle; import android.os.Handler; import android.os.Message; import android.os.Messenger; -import android.support.v4.app.Fragment; import android.support.v4.app.FragmentManager; import android.support.v4.app.FragmentManager.OnBackStackChangedListener; import android.support.v4.app.LoaderManager; @@ -45,12 +43,11 @@ import org.sufficientlysecure.keychain.provider.KeychainDatabase.Tables; import org.sufficientlysecure.keychain.service.CertifyActionsParcel; import org.sufficientlysecure.keychain.service.CertifyActionsParcel.CertifyAction; import org.sufficientlysecure.keychain.service.KeychainIntentService; -import org.sufficientlysecure.keychain.service.PassphraseCacheService; import org.sufficientlysecure.keychain.service.ServiceProgressHandler; import org.sufficientlysecure.keychain.service.input.CryptoInputParcel; -import org.sufficientlysecure.keychain.ui.PassphraseDialogActivity; import org.sufficientlysecure.keychain.ui.adapter.LinkedIdsAdapter; import org.sufficientlysecure.keychain.ui.adapter.UserIdsAdapter; +import org.sufficientlysecure.keychain.ui.base.CryptoOperationFragment; import org.sufficientlysecure.keychain.ui.linked.LinkedIdViewFragment.ViewHolder.VerifyState; import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils; import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils.State; @@ -60,14 +57,11 @@ import org.sufficientlysecure.keychain.ui.util.SubtleAttentionSeeker; import org.sufficientlysecure.keychain.ui.widget.CertListWidget; import org.sufficientlysecure.keychain.ui.widget.CertifyKeySpinner; import org.sufficientlysecure.keychain.util.Log; -import org.sufficientlysecure.keychain.util.Passphrase; -public class LinkedIdViewFragment extends Fragment implements +public class LinkedIdViewFragment extends CryptoOperationFragment implements LoaderManager.LoaderCallbacks, OnBackStackChangedListener { - public static final int REQUEST_CODE_PASSPHRASE = 0x00008001; - private static final String ARG_DATA_URI = "data_uri"; private static final String ARG_LID_RANK = "rank"; private static final String ARG_IS_SECRET = "verified"; @@ -512,44 +506,20 @@ public class LinkedIdViewFragment extends Fragment implements return; } - Passphrase passphrase; - try { - passphrase = PassphraseCacheService.getCachedPassphrase( - getActivity(), mCertifyKeyId, mCertifyKeyId); - } catch (PassphraseCacheService.KeyNotFoundException e) { - Log.e(Constants.TAG, "Key not found!", e); - getActivity().finish(); - return; - } - if (passphrase == null) { - Intent intent = new Intent(getActivity(), PassphraseDialogActivity.class); - intent.putExtra(PassphraseDialogActivity.EXTRA_SUBKEY_ID, mCertifyKeyId); - startActivityForResult(intent, REQUEST_CODE_PASSPHRASE); - // bail out; need to wait until the user has entered the passphrase before trying again - } else { - certifyResource(new CryptoInputParcel()); - } + cryptoOperation(); } @Override - public void onActivityResult(int requestCode, int resultCode, Intent data) { - switch (requestCode) { - case REQUEST_CODE_PASSPHRASE: { - if (resultCode == Activity.RESULT_OK && data != null) { - CryptoInputParcel cryptoInput = data.getParcelableExtra( - PassphraseDialogActivity.RESULT_CRYPTO_INPUT); - certifyResource(cryptoInput); - } - return; - } + protected void onCryptoOperationCancelled() { + super.onCryptoOperationCancelled(); + + // go back to 'verified ok' + setShowVerifying(false); - default: { - super.onActivityResult(requestCode, resultCode, data); - } - } } - private void certifyResource(CryptoInputParcel cryptoInput) { + @Override + protected void cryptoOperation(CryptoInputParcel cryptoInput) { if (mIsSecret) { return; @@ -588,9 +558,13 @@ public class LinkedIdViewFragment extends Fragment implements // handle messages by standard KeychainIntentServiceHandler first super.handleMessage(message); - Bundle data = message.getData(); + // handle pending messages + if (handlePendingMessage(message)) { + return; + } if (message.arg1 == MessageStatus.OKAY.ordinal()) { + Bundle data = message.getData(); CertifyResult result = data.getParcelable(CertifyResult.EXTRA_RESULT); result.createNotify(getActivity()).show(); // no need to do anything else, we will get a loader refresh! -- cgit v1.2.3 From ead7597afc95706b04430e9b4171acdfa3ca4fef Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Fri, 24 Apr 2015 15:44:53 +0200 Subject: don't show key spinner for a single entry --- .../sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index 152cb8988..f618181c6 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -298,7 +298,9 @@ public class LinkedIdViewFragment extends CryptoOperationFragment implements vProgress.setDisplayedChild(1); if (!isSecret) { showButton(2); - vKeySpinnerContainer.setVisibility(View.VISIBLE); + if (!vKeySpinner.isSingleEntry()) { + vKeySpinnerContainer.setVisibility(View.VISIBLE); + } } else { showButton(1); vKeySpinnerContainer.setVisibility(View.GONE); -- cgit v1.2.3 From 608b66d192fcab62ab44d28c34171f9ca1aff38b Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Sat, 25 Apr 2015 03:39:40 +0200 Subject: change HttpsEditText to generic PrefixEditText --- .../keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java index c36f98058..d7c7a6f2e 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java @@ -107,7 +107,7 @@ public class LinkedIdCreateTwitterStep1Fragment extends Fragment { }); mEditHandle = (EditText) view.findViewById(R.id.linked_create_twitter_handle); - mEditHandle.setText("v_debug"); + mEditHandle.setText(""); return view; } -- cgit v1.2.3 From d6d678dae3ed5d794a9aa5e289197d264f6a7ff9 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Sat, 25 Apr 2015 03:40:38 +0200 Subject: update uris and cookie patterns, plus some stylings --- .../ui/linked/LinkedIdCreateFinalFragment.java | 7 +++--- .../linked/LinkedIdCreateTwitterStep1Fragment.java | 17 ++++++++++---- .../linked/LinkedIdCreateTwitterStep2Fragment.java | 5 ++++ .../keychain/ui/linked/LinkedIdWizard.java | 27 ++++++++++++++++++++-- 4 files changed, 46 insertions(+), 10 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java index b98fc6238..ef9ae9ac4 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java @@ -162,7 +162,7 @@ public abstract class LinkedIdCreateFinalFragment extends CryptoOperationFragmen } else { setVerifyProgress(false, false); // on error, show error message - result.createNotify(getActivity()).show(); + result.createNotify(getActivity()).show(LinkedIdCreateFinalFragment.this); } } }.execute(); @@ -172,7 +172,8 @@ public abstract class LinkedIdCreateFinalFragment extends CryptoOperationFragmen protected void cryptoOperation(CryptoInputParcel cryptoInput) { if (mVerifiedResource == null) { - Notify.create(getActivity(), R.string.linked_need_verify, Notify.Style.ERROR).show(); + Notify.create(getActivity(), R.string.linked_need_verify, Notify.Style.ERROR) + .show(LinkedIdCreateFinalFragment.this); return; } @@ -206,7 +207,7 @@ public abstract class LinkedIdCreateFinalFragment extends CryptoOperationFragmen // if bad -> display here! if (!result.success()) { - result.createNotify(getActivity()).show(); + result.createNotify(getActivity()).show(LinkedIdCreateFinalFragment.this); return; } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java index d7c7a6f2e..0d6d36ca4 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java @@ -66,11 +66,17 @@ public class LinkedIdCreateTwitterStep1Fragment extends Fragment { final String handle = mEditHandle.getText().toString(); + if ("".equals(handle)) { + mEditHandle.setError("Please input a Twitter handle!"); + return; + } + new AsyncTask() { @Override protected Boolean doInBackground(Void... params) { - return true; // return checkHandle(handle); + return true; + // return checkHandle(handle); } @Override @@ -79,13 +85,15 @@ public class LinkedIdCreateTwitterStep1Fragment extends Fragment { if (result == null) { Notify.create(getActivity(), - "Connection error while checking username!", Notify.Style.ERROR); + "Connection error while checking username!", + Notify.Style.ERROR).show(LinkedIdCreateTwitterStep1Fragment.this); return; } if (!result) { Notify.create(getActivity(), - "This handle does not exist on Twitter!", Notify.Style.ERROR); + "This handle does not exist on Twitter!", + Notify.Style.ERROR).show(LinkedIdCreateTwitterStep1Fragment.this); return; } @@ -107,7 +115,6 @@ public class LinkedIdCreateTwitterStep1Fragment extends Fragment { }); mEditHandle = (EditText) view.findViewById(R.id.linked_create_twitter_handle); - mEditHandle.setText(""); return view; } @@ -117,9 +124,9 @@ public class LinkedIdCreateTwitterStep1Fragment extends Fragment { HttpURLConnection nection = (HttpURLConnection) new URL("https://twitter.com/" + handle).openConnection(); nection.setRequestMethod("HEAD"); + nection.setRequestProperty("User-Agent", "OpenKeychain"); return nection.getResponseCode() == 200; } catch (IOException e) { - e.printStackTrace(); return null; } } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java index 66e86f7d4..295ef4aef 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java @@ -25,6 +25,7 @@ import android.view.View; import android.view.View.OnClickListener; import android.view.ViewGroup; import android.widget.EditText; +import android.widget.TextView; import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog; @@ -79,6 +80,10 @@ public class LinkedIdCreateTwitterStep2Fragment extends LinkedIdCreateFinalFragm } }); + ((TextView) view.findViewById(R.id.linked_tweet_published)).setText( + getString(R.string.linked_create_twitter_2_3, mResourceHandle) + ); + return view; } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdWizard.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdWizard.java index 161efc8fb..6165efd90 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdWizard.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdWizard.java @@ -17,11 +17,14 @@ package org.sufficientlysecure.keychain.ui.linked; +import android.content.Context; import android.net.Uri; import android.os.Bundle; import android.support.v4.app.Fragment; import android.support.v4.app.FragmentTransaction; import android.support.v7.app.ActionBarActivity; +import android.view.View; +import android.view.inputmethod.InputMethodManager; import org.sufficientlysecure.keychain.Constants; import org.sufficientlysecure.keychain.R; @@ -29,9 +32,10 @@ import org.sufficientlysecure.keychain.pgp.exception.PgpKeyNotFoundException; import org.sufficientlysecure.keychain.provider.CachedPublicKeyRing; import org.sufficientlysecure.keychain.provider.KeychainContract; import org.sufficientlysecure.keychain.provider.ProviderHelper; +import org.sufficientlysecure.keychain.ui.base.BaseActivity; import org.sufficientlysecure.keychain.util.Log; -public class LinkedIdWizard extends ActionBarActivity { +public class LinkedIdWizard extends BaseActivity { public static final int FRAG_ACTION_START = 0; public static final int FRAG_ACTION_TO_RIGHT = 1; @@ -44,7 +48,7 @@ public class LinkedIdWizard extends ActionBarActivity { public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); - setContentView(R.layout.create_key_activity); + setTitle(getString(R.string.title_linked_id_create)); try { Uri uri = getIntent().getData(); @@ -69,6 +73,11 @@ public class LinkedIdWizard extends ActionBarActivity { loadFragment(null, frag, FRAG_ACTION_START); } + @Override + protected void initLayout() { + setContentView(R.layout.create_key_activity); + } + public void loadFragment(Bundle savedInstanceState, Fragment fragment, int action) { // However, if we're being restored from a previous state, // then we don't need to do anything and should return or else @@ -77,6 +86,8 @@ public class LinkedIdWizard extends ActionBarActivity { return; } + hideKeyboard(); + // Add the fragment to the 'fragment_container' FrameLayout // NOTE: We use commitAllowingStateLoss() to prevent weird crashes! FragmentTransaction transaction = getSupportFragmentManager().beginTransaction(); @@ -103,4 +114,16 @@ public class LinkedIdWizard extends ActionBarActivity { getSupportFragmentManager().executePendingTransactions(); } + private void hideKeyboard() { + InputMethodManager inputManager = (InputMethodManager) + getSystemService(Context.INPUT_METHOD_SERVICE); + + // check if no view has focus + View v = getCurrentFocus(); + if (v == null) + return; + + inputManager.hideSoftInputFromWindow(v.getWindowToken(), 0); + } + } -- cgit v1.2.3 From fc61208ce78e1a70dbd407bb554ff3e3edd91cea Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Mon, 27 Apr 2015 19:49:42 +0200 Subject: small ui niceties --- .../ui/linked/LinkedIdCreateTwitterStep2Fragment.java | 3 ++- .../keychain/ui/linked/LinkedIdViewFragment.java | 11 ++++++----- 2 files changed, 8 insertions(+), 6 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java index 295ef4aef..89d72faf3 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java @@ -20,6 +20,7 @@ package org.sufficientlysecure.keychain.ui.linked; import android.content.Intent; import android.net.Uri; import android.os.Bundle; +import android.text.Html; import android.view.LayoutInflater; import android.view.View; import android.view.View.OnClickListener; @@ -81,7 +82,7 @@ public class LinkedIdCreateTwitterStep2Fragment extends LinkedIdCreateFinalFragm }); ((TextView) view.findViewById(R.id.linked_tweet_published)).setText( - getString(R.string.linked_create_twitter_2_3, mResourceHandle) + Html.fromHtml(getString(R.string.linked_create_twitter_2_3, mResourceHandle)) ); return view; diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index f618181c6..f4987d137 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -3,7 +3,6 @@ package org.sufficientlysecure.keychain.ui.linked; import java.io.IOException; import java.util.Collections; -import android.animation.ObjectAnimator; import android.content.Context; import android.content.Intent; import android.database.Cursor; @@ -26,6 +25,7 @@ import android.view.View.OnClickListener; import android.view.ViewGroup; import android.widget.ImageView; import android.widget.TextSwitcher; +import android.widget.TextView; import android.widget.ViewAnimator; import org.sufficientlysecure.keychain.Constants; @@ -477,10 +477,11 @@ public class LinkedIdViewFragment extends CryptoOperationFragment implements } if (result.success()) { mViewHolder.vText.setText(getString(mLinkedResource.getVerifiedText(mIsSecret))); + // hack to preserve bold text + ((TextView) mViewHolder.vText.getCurrentView()).setText( + mLinkedResource.getVerifiedText(mIsSecret)); mViewHolder.setVerifyingState(mContext, VerifyState.VERIFY_OK, mIsSecret); - ObjectAnimator anim = SubtleAttentionSeeker.tada(mViewHolder.vButtonConfirm, 0.6f, 1000); - anim.setStartDelay(800); - anim.start(); + mViewHolder.mLinkedIdHolder.seekAttention(); } else { mViewHolder.setVerifyingState(mContext, VerifyState.VERIFY_ERROR, mIsSecret); result.createNotify(getActivity()).show(); @@ -501,7 +502,7 @@ public class LinkedIdViewFragment extends CryptoOperationFragment implements mCertifyKeyId = mViewHolder.vKeySpinner.getSelectedItemId(); if (mCertifyKeyId == key.none || mCertifyKeyId == key.symmetric) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) { - SubtleAttentionSeeker.tint(mViewHolder.vKeySpinnerContainer, 600).start(); + SubtleAttentionSeeker.tintBackground(mViewHolder.vKeySpinnerContainer, 600).start(); } else { Notify.create(getActivity(), R.string.select_key_to_certify, Style.ERROR).show(); } -- cgit v1.2.3 From 4378f8f871f6a47321352f90a59cfaad7f52279b Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Sat, 9 May 2015 12:24:48 +0200 Subject: linked-ids: code cleanup, handle all lint errors --- .../ui/linked/LinkedIdCreateDnsStep1Fragment.java | 7 +--- .../ui/linked/LinkedIdCreateDnsStep2Fragment.java | 41 ++++++++++----------- .../ui/linked/LinkedIdCreateFinalFragment.java | 4 +- .../linked/LinkedIdCreateGithubStep1Fragment.java | 8 +--- .../linked/LinkedIdCreateGithubStep2Fragment.java | 34 +++++++++-------- .../linked/LinkedIdCreateHttpsStep1Fragment.java | 3 +- .../linked/LinkedIdCreateHttpsStep2Fragment.java | 33 +++++++++-------- .../linked/LinkedIdCreateTwitterStep1Fragment.java | 6 +-- .../linked/LinkedIdCreateTwitterStep2Fragment.java | 43 +++++++++++----------- .../keychain/ui/linked/LinkedIdViewFragment.java | 8 ++-- .../keychain/ui/linked/LinkedIdWizard.java | 1 - 11 files changed, 92 insertions(+), 96 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java index 6b3eef26a..8062428e3 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep1Fragment.java @@ -29,8 +29,7 @@ import android.view.ViewGroup; import android.widget.EditText; import org.sufficientlysecure.keychain.R; -import org.sufficientlysecure.keychain.pgp.linked.RawLinkedIdentity; -import org.sufficientlysecure.keychain.pgp.linked.resources.DnsResource; +import org.sufficientlysecure.keychain.linked.resources.DnsResource; public class LinkedIdCreateDnsStep1Fragment extends Fragment { @@ -73,7 +72,7 @@ public class LinkedIdCreateDnsStep1Fragment extends Fragment { return; } - String proofText = DnsResource.generateText(getActivity(), + String proofText = DnsResource.generateText( mLinkedIdWizard.mFingerprint); LinkedIdCreateDnsStep2Fragment frag = @@ -120,8 +119,6 @@ public class LinkedIdCreateDnsStep1Fragment extends Fragment { } }); - mEditDns.setText("test.mugenguild.com"); - return view; } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java index e8668dc90..e72366fe1 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java @@ -19,26 +19,21 @@ package org.sufficientlysecure.keychain.ui.linked; import android.content.Intent; import android.net.Uri; -import android.os.Build; import android.os.Bundle; -import android.os.Environment; import android.view.LayoutInflater; import android.view.View; import android.view.View.OnClickListener; import android.view.ViewGroup; import android.widget.TextView; -import org.sufficientlysecure.keychain.Constants; import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.compatibility.ClipboardReflection; import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog; -import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; -import org.sufficientlysecure.keychain.pgp.linked.resources.DnsResource; +import org.sufficientlysecure.keychain.linked.LinkedCookieResource; +import org.sufficientlysecure.keychain.linked.resources.DnsResource; import org.sufficientlysecure.keychain.ui.util.Notify; import org.sufficientlysecure.keychain.ui.util.Notify.Style; -import org.sufficientlysecure.keychain.util.FileHelper; -import java.io.File; import java.io.FileNotFoundException; import java.io.PrintWriter; @@ -84,22 +79,26 @@ public class LinkedIdCreateDnsStep2Fragment extends LinkedIdCreateFinalFragment public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View view = super.onCreateView(inflater, container, savedInstanceState); - view.findViewById(R.id.button_send).setOnClickListener(new OnClickListener() { - @Override - public void onClick(View v) { - proofSend(); - } - }); + if (view != null) { - view.findViewById(R.id.button_save).setOnClickListener(new OnClickListener() { - @Override - public void onClick(View v) { - proofToClipboard(); - } - }); + view.findViewById(R.id.button_send).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + proofSend(); + } + }); - mTextView = (TextView) view.findViewById(R.id.linked_create_dns_text); - mTextView.setText(mResourceString); + view.findViewById(R.id.button_save).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + proofToClipboard(); + } + }); + + mTextView = (TextView) view.findViewById(R.id.linked_create_dns_text); + mTextView.setText(mResourceString); + + } return view; } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java index ef9ae9ac4..5b3250644 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java @@ -20,8 +20,8 @@ import org.sufficientlysecure.keychain.operations.results.LinkedVerifyResult; import org.sufficientlysecure.keychain.operations.results.OperationResult; import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog; import org.sufficientlysecure.keychain.pgp.WrappedUserAttribute; -import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; -import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; +import org.sufficientlysecure.keychain.linked.LinkedCookieResource; +import org.sufficientlysecure.keychain.linked.LinkedIdentity; import org.sufficientlysecure.keychain.service.KeychainIntentService; import org.sufficientlysecure.keychain.service.SaveKeyringParcel; import org.sufficientlysecure.keychain.service.ServiceProgressHandler; diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep1Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep1Fragment.java index 77eccf3be..b166b3e4f 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep1Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep1Fragment.java @@ -17,11 +17,6 @@ package org.sufficientlysecure.keychain.ui.linked; - -import java.io.IOException; -import java.net.HttpURLConnection; -import java.net.URL; - import android.os.AsyncTask; import android.os.Bundle; import android.support.v4.app.Fragment; @@ -109,11 +104,11 @@ public class LinkedIdCreateGithubStep1Fragment extends Fragment { }); mEditHandle = (EditText) view.findViewById(R.id.linked_create_github_handle); - mEditHandle.setText("Valodim"); return view; } + /* not used at this point, too much hassle private static Boolean checkHandle(String handle) { try { HttpURLConnection nection = @@ -125,5 +120,6 @@ public class LinkedIdCreateGithubStep1Fragment extends Fragment { return null; } } + */ } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep2Fragment.java index cc1052b1f..95c029738 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep2Fragment.java @@ -27,8 +27,8 @@ import android.view.ViewGroup; import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog; -import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; -import org.sufficientlysecure.keychain.pgp.linked.resources.GithubResource; +import org.sufficientlysecure.keychain.linked.LinkedCookieResource; +import org.sufficientlysecure.keychain.linked.resources.GithubResource; public class LinkedIdCreateGithubStep2Fragment extends LinkedIdCreateFinalFragment { @@ -65,19 +65,23 @@ public class LinkedIdCreateGithubStep2Fragment extends LinkedIdCreateFinalFragme public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View view = super.onCreateView(inflater, container, savedInstanceState); - view.findViewById(R.id.button_send).setOnClickListener(new OnClickListener() { - @Override - public void onClick(View v) { - proofSend(); - } - }); - - view.findViewById(R.id.button_share).setOnClickListener(new OnClickListener() { - @Override - public void onClick(View v) { - proofShare(); - } - }); + if (view != null) { + + view.findViewById(R.id.button_send).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + proofSend(); + } + }); + + view.findViewById(R.id.button_share).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + proofShare(); + } + }); + + } return view; } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java index 72669142b..5a8b4a72a 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java @@ -29,8 +29,7 @@ import android.view.ViewGroup; import android.widget.EditText; import org.sufficientlysecure.keychain.R; -import org.sufficientlysecure.keychain.pgp.linked.RawLinkedIdentity; -import org.sufficientlysecure.keychain.pgp.linked.resources.GenericHttpsResource; +import org.sufficientlysecure.keychain.linked.resources.GenericHttpsResource; public class LinkedIdCreateHttpsStep1Fragment extends Fragment { diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java index 6bb555105..2af97fe36 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep2Fragment.java @@ -31,7 +31,7 @@ import android.widget.EditText; import org.sufficientlysecure.keychain.Constants; import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog; -import org.sufficientlysecure.keychain.pgp.linked.resources.GenericHttpsResource; +import org.sufficientlysecure.keychain.linked.resources.GenericHttpsResource; import org.sufficientlysecure.keychain.ui.util.Notify; import org.sufficientlysecure.keychain.ui.util.Notify.Style; import org.sufficientlysecure.keychain.util.FileHelper; @@ -95,22 +95,25 @@ public class LinkedIdCreateHttpsStep2Fragment extends LinkedIdCreateFinalFragmen public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View view = super.onCreateView(inflater, container, savedInstanceState); - view.findViewById(R.id.button_send).setOnClickListener(new OnClickListener() { - @Override - public void onClick(View v) { - proofSend(); - } - }); + if (view != null) { - view.findViewById(R.id.button_save).setOnClickListener(new OnClickListener() { - @Override - public void onClick(View v) { - proofSave(); - } - }); + view.findViewById(R.id.button_send).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + proofSend(); + } + }); - mEditUri = (EditText) view.findViewById(R.id.linked_create_https_uri); - mEditUri.setText(mResourceUri.toString()); + view.findViewById(R.id.button_save).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + proofSave(); + } + }); + + mEditUri = (EditText) view.findViewById(R.id.linked_create_https_uri); + mEditUri.setText(mResourceUri.toString()); + } return view; } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java index 0d6d36ca4..c25f775b0 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep1Fragment.java @@ -29,10 +29,6 @@ import android.widget.EditText; import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.ui.util.Notify; -import java.io.IOException; -import java.net.HttpURLConnection; -import java.net.URL; - public class LinkedIdCreateTwitterStep1Fragment extends Fragment { LinkedIdWizard mLinkedIdWizard; @@ -119,6 +115,7 @@ public class LinkedIdCreateTwitterStep1Fragment extends Fragment { return view; } + /* not used at this point, too many problems private static Boolean checkHandle(String handle) { try { HttpURLConnection nection = @@ -130,5 +127,6 @@ public class LinkedIdCreateTwitterStep1Fragment extends Fragment { return null; } } + */ } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java index 89d72faf3..ebfbfd16b 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java @@ -25,13 +25,12 @@ import android.view.LayoutInflater; import android.view.View; import android.view.View.OnClickListener; import android.view.ViewGroup; -import android.widget.EditText; import android.widget.TextView; import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog; -import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; -import org.sufficientlysecure.keychain.pgp.linked.resources.TwitterResource; +import org.sufficientlysecure.keychain.linked.LinkedCookieResource; +import org.sufficientlysecure.keychain.linked.resources.TwitterResource; public class LinkedIdCreateTwitterStep2Fragment extends LinkedIdCreateFinalFragment { @@ -57,7 +56,7 @@ public class LinkedIdCreateTwitterStep2Fragment extends LinkedIdCreateFinalFragm super.onCreate(savedInstanceState); mResourceString = - TwitterResource.generate(getActivity(), mLinkedIdWizard.mFingerprint); + TwitterResource.generate(mLinkedIdWizard.mFingerprint); mResourceHandle = getArguments().getString(ARG_HANDLE); @@ -67,23 +66,25 @@ public class LinkedIdCreateTwitterStep2Fragment extends LinkedIdCreateFinalFragm public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View view = super.onCreateView(inflater, container, savedInstanceState); - view.findViewById(R.id.button_send).setOnClickListener(new OnClickListener() { - @Override - public void onClick(View v) { - proofSend(); - } - }); - - view.findViewById(R.id.button_share).setOnClickListener(new OnClickListener() { - @Override - public void onClick(View v) { - proofShare(); - } - }); - - ((TextView) view.findViewById(R.id.linked_tweet_published)).setText( - Html.fromHtml(getString(R.string.linked_create_twitter_2_3, mResourceHandle)) - ); + if (view != null) { + view.findViewById(R.id.button_send).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + proofSend(); + } + }); + + view.findViewById(R.id.button_share).setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + proofShare(); + } + }); + + ((TextView) view.findViewById(R.id.linked_tweet_published)).setText( + Html.fromHtml(getString(R.string.linked_create_twitter_2_3, mResourceHandle)) + ); + } return view; } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index f4987d137..d2ae69a24 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -33,10 +33,10 @@ import org.sufficientlysecure.keychain.Constants.key; import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.operations.results.CertifyResult; import org.sufficientlysecure.keychain.operations.results.LinkedVerifyResult; -import org.sufficientlysecure.keychain.pgp.linked.LinkedCookieResource; -import org.sufficientlysecure.keychain.pgp.linked.LinkedIdentity; -import org.sufficientlysecure.keychain.pgp.linked.LinkedResource; -import org.sufficientlysecure.keychain.pgp.linked.RawLinkedIdentity; +import org.sufficientlysecure.keychain.linked.LinkedCookieResource; +import org.sufficientlysecure.keychain.linked.LinkedIdentity; +import org.sufficientlysecure.keychain.linked.LinkedResource; +import org.sufficientlysecure.keychain.linked.RawLinkedIdentity; import org.sufficientlysecure.keychain.provider.KeychainContract.Certs; import org.sufficientlysecure.keychain.provider.KeychainContract.UserPackets; import org.sufficientlysecure.keychain.provider.KeychainDatabase.Tables; diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdWizard.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdWizard.java index 6165efd90..a29f175c0 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdWizard.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdWizard.java @@ -22,7 +22,6 @@ import android.net.Uri; import android.os.Bundle; import android.support.v4.app.Fragment; import android.support.v4.app.FragmentTransaction; -import android.support.v7.app.ActionBarActivity; import android.view.View; import android.view.inputmethod.InputMethodManager; -- cgit v1.2.3 From 57f72996e8e0db35e629ffd48f58cb5812f47788 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Sat, 9 May 2015 12:29:43 +0200 Subject: linked-ids: rename "cookie" to "token" --- .../keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java | 4 ++-- .../keychain/ui/linked/LinkedIdCreateFinalFragment.java | 8 ++++---- .../keychain/ui/linked/LinkedIdCreateGithubStep2Fragment.java | 4 ++-- .../keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java | 4 ++-- .../keychain/ui/linked/LinkedIdViewFragment.java | 6 +++--- 5 files changed, 13 insertions(+), 13 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java index e72366fe1..e0e6976ee 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateDnsStep2Fragment.java @@ -29,7 +29,7 @@ import android.widget.TextView; import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.compatibility.ClipboardReflection; import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog; -import org.sufficientlysecure.keychain.linked.LinkedCookieResource; +import org.sufficientlysecure.keychain.linked.LinkedTokenResource; import org.sufficientlysecure.keychain.linked.resources.DnsResource; import org.sufficientlysecure.keychain.ui.util.Notify; import org.sufficientlysecure.keychain.ui.util.Notify.Style; @@ -104,7 +104,7 @@ public class LinkedIdCreateDnsStep2Fragment extends LinkedIdCreateFinalFragment } @Override - LinkedCookieResource getResource(OperationLog log) { + LinkedTokenResource getResource(OperationLog log) { return DnsResource.createNew(mResourceDomain); } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java index 5b3250644..985cb6f18 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java @@ -20,7 +20,7 @@ import org.sufficientlysecure.keychain.operations.results.LinkedVerifyResult; import org.sufficientlysecure.keychain.operations.results.OperationResult; import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog; import org.sufficientlysecure.keychain.pgp.WrappedUserAttribute; -import org.sufficientlysecure.keychain.linked.LinkedCookieResource; +import org.sufficientlysecure.keychain.linked.LinkedTokenResource; import org.sufficientlysecure.keychain.linked.LinkedIdentity; import org.sufficientlysecure.keychain.service.KeychainIntentService; import org.sufficientlysecure.keychain.service.SaveKeyringParcel; @@ -39,7 +39,7 @@ public abstract class LinkedIdCreateFinalFragment extends CryptoOperationFragmen private ViewAnimator mVerifyAnimator; // This is a resource, set AFTER it has been verified - LinkedCookieResource mVerifiedResource = null; + LinkedTokenResource mVerifiedResource = null; private ViewAnimator mVerifyButtonAnimator; @Override @@ -94,7 +94,7 @@ public abstract class LinkedIdCreateFinalFragment extends CryptoOperationFragmen return view; } - abstract LinkedCookieResource getResource(OperationLog log); + abstract LinkedTokenResource getResource(OperationLog log); private void setVerifyProgress(boolean on, Boolean success) { if (success == null) { @@ -133,7 +133,7 @@ public abstract class LinkedIdCreateFinalFragment extends CryptoOperationFragmen long timer = System.currentTimeMillis(); OperationLog log = new OperationLog(); - LinkedCookieResource resource = getResource(log); + LinkedTokenResource resource = getResource(log); if (resource == null) { return new LinkedVerifyResult(LinkedVerifyResult.RESULT_ERROR, log); } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep2Fragment.java index 95c029738..6e85193a7 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep2Fragment.java @@ -27,7 +27,7 @@ import android.view.ViewGroup; import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog; -import org.sufficientlysecure.keychain.linked.LinkedCookieResource; +import org.sufficientlysecure.keychain.linked.LinkedTokenResource; import org.sufficientlysecure.keychain.linked.resources.GithubResource; @@ -87,7 +87,7 @@ public class LinkedIdCreateGithubStep2Fragment extends LinkedIdCreateFinalFragme } @Override - LinkedCookieResource getResource(OperationLog log) { + LinkedTokenResource getResource(OperationLog log) { return GithubResource.searchInGithubStream(mResourceHandle, mResourceString, log); } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java index ebfbfd16b..aa9354a04 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java @@ -29,7 +29,7 @@ import android.widget.TextView; import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog; -import org.sufficientlysecure.keychain.linked.LinkedCookieResource; +import org.sufficientlysecure.keychain.linked.LinkedTokenResource; import org.sufficientlysecure.keychain.linked.resources.TwitterResource; public class LinkedIdCreateTwitterStep2Fragment extends LinkedIdCreateFinalFragment { @@ -90,7 +90,7 @@ public class LinkedIdCreateTwitterStep2Fragment extends LinkedIdCreateFinalFragm } @Override - LinkedCookieResource getResource(OperationLog log) { + LinkedTokenResource getResource(OperationLog log) { return TwitterResource.searchInTwitterStream(mResourceHandle, mResourceString, log); } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index d2ae69a24..c3dcaf239 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -33,7 +33,7 @@ import org.sufficientlysecure.keychain.Constants.key; import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.operations.results.CertifyResult; import org.sufficientlysecure.keychain.operations.results.LinkedVerifyResult; -import org.sufficientlysecure.keychain.linked.LinkedCookieResource; +import org.sufficientlysecure.keychain.linked.LinkedTokenResource; import org.sufficientlysecure.keychain.linked.LinkedIdentity; import org.sufficientlysecure.keychain.linked.LinkedResource; import org.sufficientlysecure.keychain.linked.RawLinkedIdentity; @@ -69,7 +69,7 @@ public class LinkedIdViewFragment extends CryptoOperationFragment implements private static final int LOADER_ID_LINKED_ID = 1; private RawLinkedIdentity mLinkedId; - private LinkedCookieResource mLinkedResource; + private LinkedTokenResource mLinkedResource; private boolean mIsSecret; private Context mContext; @@ -191,7 +191,7 @@ public class LinkedIdViewFragment extends CryptoOperationFragment implements if (mLinkedId instanceof LinkedIdentity) { LinkedResource res = ((LinkedIdentity) mLinkedId).mResource; - mLinkedResource = (LinkedCookieResource) res; + mLinkedResource = (LinkedTokenResource) res; } if (!mIsSecret) { -- cgit v1.2.3 From 3600cda3bcf1797db60c870a5fa582a27856e666 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Sat, 9 May 2015 19:09:09 +0200 Subject: linked-ids: rename RawLinkedIdentity to UriAttribute --- .../keychain/ui/linked/LinkedIdViewFragment.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index c3dcaf239..00eeb5de6 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -36,7 +36,7 @@ import org.sufficientlysecure.keychain.operations.results.LinkedVerifyResult; import org.sufficientlysecure.keychain.linked.LinkedTokenResource; import org.sufficientlysecure.keychain.linked.LinkedIdentity; import org.sufficientlysecure.keychain.linked.LinkedResource; -import org.sufficientlysecure.keychain.linked.RawLinkedIdentity; +import org.sufficientlysecure.keychain.linked.UriAttribute; import org.sufficientlysecure.keychain.provider.KeychainContract.Certs; import org.sufficientlysecure.keychain.provider.KeychainContract.UserPackets; import org.sufficientlysecure.keychain.provider.KeychainDatabase.Tables; @@ -68,7 +68,7 @@ public class LinkedIdViewFragment extends CryptoOperationFragment implements private static final String ARG_FINGERPRINT = "fingerprint"; private static final int LOADER_ID_LINKED_ID = 1; - private RawLinkedIdentity mLinkedId; + private UriAttribute mLinkedId; private LinkedTokenResource mLinkedResource; private boolean mIsSecret; @@ -147,7 +147,7 @@ public class LinkedIdViewFragment extends CryptoOperationFragment implements int certStatus = cursor.getInt(UserIdsAdapter.INDEX_VERIFIED); byte[] data = cursor.getBlob(UserIdsAdapter.INDEX_ATTRIBUTE_DATA); - RawLinkedIdentity linkedId = LinkedIdentity.fromAttributeData(data); + UriAttribute linkedId = LinkedIdentity.fromAttributeData(data); loadIdentity(linkedId, certStatus); @@ -186,7 +186,7 @@ public class LinkedIdViewFragment extends CryptoOperationFragment implements mIdLoadedListener = listener; } - private void loadIdentity(RawLinkedIdentity linkedId, int certStatus) { + private void loadIdentity(UriAttribute linkedId, int certStatus) { mLinkedId = linkedId; if (mLinkedId instanceof LinkedIdentity) { -- cgit v1.2.3 From 9aff6c7f8527f3eb78a14c62a677a2fd0631130e Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Sat, 9 May 2015 19:26:11 +0200 Subject: linked-ids: add certificate pinning, pin twitter api cert --- .../keychain/ui/linked/LinkedIdCreateFinalFragment.java | 2 +- .../keychain/ui/linked/LinkedIdCreateGithubStep2Fragment.java | 2 +- .../keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java | 3 ++- 3 files changed, 4 insertions(+), 3 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java index 985cb6f18..4927064e4 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java @@ -138,7 +138,7 @@ public abstract class LinkedIdCreateFinalFragment extends CryptoOperationFragmen return new LinkedVerifyResult(LinkedVerifyResult.RESULT_ERROR, log); } - LinkedVerifyResult result = resource.verify(mLinkedIdWizard.mFingerprint); + LinkedVerifyResult result = resource.verify(getActivity(), mLinkedIdWizard.mFingerprint); // ux flow: this operation should take at last a second timer = System.currentTimeMillis() -timer; diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep2Fragment.java index 6e85193a7..a3a8c779f 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateGithubStep2Fragment.java @@ -88,7 +88,7 @@ public class LinkedIdCreateGithubStep2Fragment extends LinkedIdCreateFinalFragme @Override LinkedTokenResource getResource(OperationLog log) { - return GithubResource.searchInGithubStream(mResourceHandle, mResourceString, log); + return GithubResource.searchInGithubStream(getActivity(), mResourceHandle, mResourceString, log); } @Override diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java index aa9354a04..362798bc8 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateTwitterStep2Fragment.java @@ -91,7 +91,8 @@ public class LinkedIdCreateTwitterStep2Fragment extends LinkedIdCreateFinalFragm @Override LinkedTokenResource getResource(OperationLog log) { - return TwitterResource.searchInTwitterStream(mResourceHandle, mResourceString, log); + return TwitterResource.searchInTwitterStream(getActivity(), + mResourceHandle, mResourceString, log); } @Override -- cgit v1.2.3 From 92ac2ded10548756922a4c22ebae0a19b8862426 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Mon, 11 May 2015 17:00:45 +0200 Subject: linked-ids: small compatibility changes --- .../org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index 00eeb5de6..7e9aaf25e 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -457,7 +457,7 @@ public class LinkedIdViewFragment extends CryptoOperationFragment implements @Override protected LinkedVerifyResult doInBackground(Void... params) { long timer = System.currentTimeMillis(); - LinkedVerifyResult result = mLinkedResource.verify(mFingerprint); + LinkedVerifyResult result = mLinkedResource.verify(getActivity(), mFingerprint); // ux flow: this operation should take at last a second timer = System.currentTimeMillis() -timer; -- cgit v1.2.3 From 6fe0a555228bd6fee95cc6f992986f91392ff736 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Tue, 12 May 2015 11:56:39 +0200 Subject: rename LinkedIdentity to LinkedAttribute --- .../keychain/ui/linked/LinkedIdCreateFinalFragment.java | 4 ++-- .../keychain/ui/linked/LinkedIdViewFragment.java | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java index 4927064e4..eedc7cdd9 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateFinalFragment.java @@ -21,7 +21,7 @@ import org.sufficientlysecure.keychain.operations.results.OperationResult; import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog; import org.sufficientlysecure.keychain.pgp.WrappedUserAttribute; import org.sufficientlysecure.keychain.linked.LinkedTokenResource; -import org.sufficientlysecure.keychain.linked.LinkedIdentity; +import org.sufficientlysecure.keychain.linked.LinkedAttribute; import org.sufficientlysecure.keychain.service.KeychainIntentService; import org.sufficientlysecure.keychain.service.SaveKeyringParcel; import org.sufficientlysecure.keychain.service.ServiceProgressHandler; @@ -221,7 +221,7 @@ public abstract class LinkedIdCreateFinalFragment extends CryptoOperationFragmen new SaveKeyringParcel(mLinkedIdWizard.mMasterKeyId, mLinkedIdWizard.mFingerprint); WrappedUserAttribute ua = - LinkedIdentity.fromResource(mVerifiedResource).toUserAttribute(); + LinkedAttribute.fromResource(mVerifiedResource).toUserAttribute(); skp.mAddUserAttribute.add(ua); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java index 7e9aaf25e..82aaa51c4 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdViewFragment.java @@ -34,7 +34,7 @@ import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.operations.results.CertifyResult; import org.sufficientlysecure.keychain.operations.results.LinkedVerifyResult; import org.sufficientlysecure.keychain.linked.LinkedTokenResource; -import org.sufficientlysecure.keychain.linked.LinkedIdentity; +import org.sufficientlysecure.keychain.linked.LinkedAttribute; import org.sufficientlysecure.keychain.linked.LinkedResource; import org.sufficientlysecure.keychain.linked.UriAttribute; import org.sufficientlysecure.keychain.provider.KeychainContract.Certs; @@ -147,7 +147,7 @@ public class LinkedIdViewFragment extends CryptoOperationFragment implements int certStatus = cursor.getInt(UserIdsAdapter.INDEX_VERIFIED); byte[] data = cursor.getBlob(UserIdsAdapter.INDEX_ATTRIBUTE_DATA); - UriAttribute linkedId = LinkedIdentity.fromAttributeData(data); + UriAttribute linkedId = LinkedAttribute.fromAttributeData(data); loadIdentity(linkedId, certStatus); @@ -189,8 +189,8 @@ public class LinkedIdViewFragment extends CryptoOperationFragment implements private void loadIdentity(UriAttribute linkedId, int certStatus) { mLinkedId = linkedId; - if (mLinkedId instanceof LinkedIdentity) { - LinkedResource res = ((LinkedIdentity) mLinkedId).mResource; + if (mLinkedId instanceof LinkedAttribute) { + LinkedResource res = ((LinkedAttribute) mLinkedId).mResource; mLinkedResource = (LinkedTokenResource) res; } -- cgit v1.2.3 From f188b5b9b744016312a2cfb3ee4ea4f8edf459c0 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Fri, 15 May 2015 01:05:10 +0200 Subject: linked-ids: remove debug uri --- .../keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked') diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java index 5a8b4a72a..7bc33c93b 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/linked/LinkedIdCreateHttpsStep1Fragment.java @@ -115,7 +115,7 @@ public class LinkedIdCreateHttpsStep1Fragment extends Fragment { } }); - mEditUri.setText("mugenguild.com/pgpkey.txt"); + // mEditUri.setText("mugenguild.com/pgpkey.txt"); return view; } -- cgit v1.2.3