Java tutorial
/* * Copyright (C) 2014 Vincent Breitmoser <v.breitmoser@mugenguild.com> * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ package org.sufficientlysecure.keychain.ui.linked; import java.io.IOException; import java.util.Collections; 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.Build; import android.os.Bundle; import android.os.Handler; import android.os.Parcelable; import android.support.annotation.Nullable; 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; import android.view.LayoutInflater; import android.view.View; 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; import org.sufficientlysecure.keychain.Constants.key; import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.operations.results.LinkedVerifyResult; import org.sufficientlysecure.keychain.linked.LinkedTokenResource; import org.sufficientlysecure.keychain.linked.LinkedAttribute; import org.sufficientlysecure.keychain.linked.LinkedResource; import org.sufficientlysecure.keychain.linked.UriAttribute; import org.sufficientlysecure.keychain.operations.results.OperationResult; 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.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; 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; public class LinkedIdViewFragment extends CryptoOperationFragment implements LoaderManager.LoaderCallbacks<Cursor>, OnBackStackChangedListener { 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"; private static final String ARG_FINGERPRINT = "fingerprint"; private static final int LOADER_ID_LINKED_ID = 1; private UriAttribute mLinkedId; private LinkedTokenResource mLinkedResource; private boolean mIsSecret; private Context mContext; private byte[] mFingerprint; private AsyncTask mInProgress; private Uri mDataUri; private ViewHolder mViewHolder; private int mLidRank; private OnIdentityLoadedListener mIdLoadedListener; private long mCertifyKeyId; public static LinkedIdViewFragment newInstance(Uri dataUri, int rank, 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_IS_SECRET, isSecret); args.putByteArray(ARG_FINGERPRINT, fingerprint); frag.setArguments(args); return frag; } public LinkedIdViewFragment() { // IMPORTANT: the id must be unique in the ViewKeyActivity CryptoOperationHelper id namespace! // no initial progress message -> we handle progress ourselves! super(5, null); } @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Bundle args = getArguments(); mDataUri = args.getParcelable(ARG_DATA_URI); mLidRank = args.getInt(ARG_LID_RANK); mIsSecret = args.getBoolean(ARG_IS_SECRET); mFingerprint = args.getByteArray(ARG_FINGERPRINT); mContext = getActivity(); getLoaderManager().initLoader(LOADER_ID_LINKED_ID, null, this); } @Override public Loader<Cursor> 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); default: return null; } } @Override public void onLoadFinished(Loader<Cursor> loader, Cursor cursor) { switch (loader.getId()) { case LOADER_ID_LINKED_ID: // Nothing to load means break if we are *expected* to load if (!cursor.moveToFirst()) { 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; } try { int certStatus = cursor.getInt(UserIdsAdapter.INDEX_VERIFIED); byte[] data = cursor.getBlob(UserIdsAdapter.INDEX_ATTRIBUTE_DATA); UriAttribute linkedId = LinkedAttribute.fromAttributeData(data); loadIdentity(linkedId, certStatus); if (mIdLoadedListener != null) { mIdLoadedListener.onIdentityLoaded(); mIdLoadedListener = null; } } catch (IOException e) { Log.e(Constants.TAG, "error parsing identity", e); Notify.create(getActivity(), "Error parsing identity!", Notify.LENGTH_LONG, Style.ERROR).show(); finishFragment(); } break; } } public void finishFragment() { 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 { void onIdentityLoaded(); } public void setOnIdentityLoadedListener(OnIdentityLoadedListener listener) { mIdLoadedListener = listener; } private void loadIdentity(UriAttribute linkedId, int certStatus) { mLinkedId = linkedId; if (mLinkedId instanceof LinkedAttribute) { LinkedResource res = ((LinkedAttribute) mLinkedId).mResource; mLinkedResource = (LinkedTokenResource) res; } if (!mIsSecret) { switch (certStatus) { case Certs.VERIFIED_SECRET: KeyFormattingUtils.setStatusImage(mContext, mViewHolder.mLinkedIdHolder.vVerified, null, State.VERIFIED, KeyFormattingUtils.DEFAULT_COLOR); break; case Certs.VERIFIED_SELF: KeyFormattingUtils.setStatusImage(mContext, mViewHolder.mLinkedIdHolder.vVerified, null, State.UNVERIFIED, KeyFormattingUtils.DEFAULT_COLOR); break; default: KeyFormattingUtils.setStatusImage(mContext, mViewHolder.mLinkedIdHolder.vVerified, null, State.INVALID, KeyFormattingUtils.DEFAULT_COLOR); break; } } else { mViewHolder.mLinkedIdHolder.vVerified.setImageResource(R.drawable.octo_link_24dp); } mViewHolder.mLinkedIdHolder.setData(mContext, mLinkedId); setShowVerifying(false); // no resource, nothing further we can do if (mLinkedResource == null) { mViewHolder.vButtonView.setVisibility(View.GONE); mViewHolder.vButtonVerify.setVisibility(View.GONE); return; } if (mLinkedResource.isViewable()) { mViewHolder.vButtonView.setVisibility(View.VISIBLE); mViewHolder.vButtonView.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { Intent intent = mLinkedResource.getViewIntent(); if (intent == null) { return; } getActivity().startActivity(intent); } }); } else { mViewHolder.vButtonView.setVisibility(View.GONE); } } @Override public void onLoaderReset(Loader<Cursor> loader) { } static class ViewHolder { private final View vButtonView; private final ViewAnimator vVerifyingContainer; private final ViewAnimator vItemCertified; private final View vKeySpinnerContainer; LinkedIdsAdapter.ViewHolder mLinkedIdHolder; private ViewAnimator vButtonSwitcher; private CertListWidget vLinkedCerts; private CertifyKeySpinner vKeySpinner; private final View vButtonVerify; private final View vButtonRetry; private final View vButtonConfirm; private final ViewAnimator vProgress; private final TextSwitcher vText; 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); 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); 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 = (TextSwitcher) root.findViewById(R.id.linked_cert_text); } enum VerifyState { VERIFYING, VERIFY_OK, VERIFY_ERROR, CERTIFYING } void setVerifyingState(Context context, VerifyState state, boolean isSecret) { switch (state) { case VERIFYING: vProgress.setDisplayedChild(0); vText.setText(context.getString(R.string.linked_text_verifying)); vKeySpinnerContainer.setVisibility(View.GONE); break; case VERIFY_OK: vProgress.setDisplayedChild(1); if (!isSecret) { showButton(2); if (!vKeySpinner.isSingleEntry()) { vKeySpinnerContainer.setVisibility(View.VISIBLE); } } else { showButton(1); vKeySpinnerContainer.setVisibility(View.GONE); } break; case VERIFY_ERROR: showButton(1); vProgress.setDisplayedChild(2); vText.setText(context.getString(R.string.linked_text_error)); vKeySpinnerContainer.setVisibility(View.GONE); break; case CERTIFYING: vProgress.setDisplayedChild(0); vText.setText(context.getString(R.string.linked_text_confirming)); vKeySpinnerContainer.setVisibility(View.GONE); break; } } 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.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) { if (vButtonSwitcher.getDisplayedChild() == which) { return; } vButtonSwitcher.setDisplayedChild(which); } } 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.vKeySpinnerContainer.setVisibility(View.GONE); mViewHolder.showVerifyingContainer(mContext, false, mIsSecret); return; } if (mVerificationState) { return; } mVerificationState = true; FragmentManager manager = getFragmentManager(); manager.beginTransaction().addToBackStack("verification").commit(); manager.executePendingTransactions(); manager.addOnBackStackChangedListener(this); mViewHolder.showVerifyingContainer(mContext, true, mIsSecret); } @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); 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.vButtonVerify.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { verifyResource(); } }); mViewHolder.vButtonRetry.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { verifyResource(); } }); mViewHolder.vButtonConfirm.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { initiateCertifying(); } }); { 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); } return root; } void verifyResource() { // only one at a time (no sync needed, mInProgress is only touched in ui thread) if (mInProgress != null) { return; } setShowVerifying(true); mViewHolder.vKeySpinnerContainer.setVisibility(View.GONE); mViewHolder.setVerifyingState(mContext, VerifyState.VERIFYING, mIsSecret); mInProgress = new AsyncTask<Void, Void, LinkedVerifyResult>() { @Override protected LinkedVerifyResult doInBackground(Void... params) { long timer = System.currentTimeMillis(); LinkedVerifyResult result = mLinkedResource.verify(getActivity(), 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 } return result; } @Override protected void onPostExecute(LinkedVerifyResult result) { if (isCancelled()) { return; } 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); mViewHolder.mLinkedIdHolder.seekAttention(); } else { mViewHolder.setVerifyingState(mContext, VerifyState.VERIFY_ERROR, mIsSecret); result.createNotify(getActivity()).show(); } mInProgress = null; } }.execute(); } private void initiateCertifying() { if (mIsSecret) { return; } // get the user's passphrase for this key (if required) mCertifyKeyId = mViewHolder.vKeySpinner.getSelectedKeyId(); if (mCertifyKeyId == key.none || mCertifyKeyId == key.symmetric) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) { SubtleAttentionSeeker.tintBackground(mViewHolder.vKeySpinnerContainer, 600).start(); } else { Notify.create(getActivity(), R.string.select_key_to_certify, Style.ERROR).show(); } return; } mViewHolder.setVerifyingState(mContext, VerifyState.CERTIFYING, false); cryptoOperation(); } @Override public void onCryptoOperationCancelled() { super.onCryptoOperationCancelled(); // go back to 'verified ok' setShowVerifying(false); } @Nullable @Override public Parcelable createOperationInput() { long masterKeyId = KeyFormattingUtils.convertFingerprintToKeyId(mFingerprint); CertifyAction action = new CertifyAction(masterKeyId, null, Collections.singletonList(mLinkedId.toUserAttribute())); // fill values for this action CertifyActionsParcel parcel = new CertifyActionsParcel(mCertifyKeyId); parcel.mCertifyActions.addAll(Collections.singletonList(action)); return parcel; } @Override public void onCryptoOperationSuccess(OperationResult result) { result.createNotify(getActivity()).show(); // no need to do anything else, we will get a loader refresh! } @Override public void onCryptoOperationError(OperationResult result) { result.createNotify(getActivity()).show(); } @Override public boolean onCryptoSetProgress(String msg, int progress, int max) { return true; } }