diff options
Diffstat (limited to 'java/com/android/dialer/app/widget')
4 files changed, 735 insertions, 0 deletions
diff --git a/java/com/android/dialer/app/widget/ActionBarController.java b/java/com/android/dialer/app/widget/ActionBarController.java new file mode 100644 index 000000000..7fe056c51 --- /dev/null +++ b/java/com/android/dialer/app/widget/ActionBarController.java @@ -0,0 +1,247 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.android.dialer.app.widget; + +import android.animation.ValueAnimator; +import android.animation.ValueAnimator.AnimatorUpdateListener; +import android.os.Bundle; +import android.support.annotation.VisibleForTesting; +import android.util.Log; +import com.android.dialer.animation.AnimUtils.AnimationCallback; +import com.android.dialer.app.DialtactsActivity; + +/** + * Controls the various animated properties of the actionBar: showing/hiding, fading/revealing, and + * collapsing/expanding, and assigns suitable properties to the actionBar based on the current state + * of the UI. + */ +public class ActionBarController { + + public static final boolean DEBUG = DialtactsActivity.DEBUG; + public static final String TAG = "ActionBarController"; + private static final String KEY_IS_SLID_UP = "key_actionbar_is_slid_up"; + private static final String KEY_IS_FADED_OUT = "key_actionbar_is_faded_out"; + private static final String KEY_IS_EXPANDED = "key_actionbar_is_expanded"; + + private ActivityUi mActivityUi; + private SearchEditTextLayout mSearchBox; + + private boolean mIsActionBarSlidUp; + + private final AnimationCallback mFadeOutCallback = + new AnimationCallback() { + @Override + public void onAnimationEnd() { + slideActionBar(true /* slideUp */, false /* animate */); + } + + @Override + public void onAnimationCancel() { + slideActionBar(true /* slideUp */, false /* animate */); + } + }; + + public ActionBarController(ActivityUi activityUi, SearchEditTextLayout searchBox) { + mActivityUi = activityUi; + mSearchBox = searchBox; + } + + /** @return Whether or not the action bar is currently showing (both slid down and visible) */ + public boolean isActionBarShowing() { + return !mIsActionBarSlidUp && !mSearchBox.isFadedOut(); + } + + /** Called when the user has tapped on the collapsed search box, to start a new search query. */ + public void onSearchBoxTapped() { + if (DEBUG) { + Log.d(TAG, "OnSearchBoxTapped: isInSearchUi " + mActivityUi.isInSearchUi()); + } + if (!mActivityUi.isInSearchUi()) { + mSearchBox.expand(true /* animate */, true /* requestFocus */); + } + } + + /** Called when search UI has been exited for some reason. */ + public void onSearchUiExited() { + if (DEBUG) { + Log.d( + TAG, + "OnSearchUIExited: isExpanded " + + mSearchBox.isExpanded() + + " isFadedOut: " + + mSearchBox.isFadedOut() + + " shouldShowActionBar: " + + mActivityUi.shouldShowActionBar()); + } + if (mSearchBox.isExpanded()) { + mSearchBox.collapse(true /* animate */); + } + if (mSearchBox.isFadedOut()) { + mSearchBox.fadeIn(); + } + + if (mActivityUi.shouldShowActionBar()) { + slideActionBar(false /* slideUp */, false /* animate */); + } else { + slideActionBar(true /* slideUp */, false /* animate */); + } + } + + /** + * Called to indicate that the user is trying to hide the dialpad. Should be called before any + * state changes have actually occurred. + */ + public void onDialpadDown() { + if (DEBUG) { + Log.d( + TAG, + "OnDialpadDown: isInSearchUi " + + mActivityUi.isInSearchUi() + + " hasSearchQuery: " + + mActivityUi.hasSearchQuery() + + " isFadedOut: " + + mSearchBox.isFadedOut() + + " isExpanded: " + + mSearchBox.isExpanded()); + } + if (mActivityUi.isInSearchUi()) { + if (mActivityUi.hasSearchQuery()) { + if (mSearchBox.isFadedOut()) { + mSearchBox.setVisible(true); + } + if (!mSearchBox.isExpanded()) { + mSearchBox.expand(false /* animate */, false /* requestFocus */); + } + slideActionBar(false /* slideUp */, true /* animate */); + } else { + mSearchBox.fadeIn(); + } + } + } + + /** + * Called to indicate that the user is trying to show the dialpad. Should be called before any + * state changes have actually occurred. + */ + public void onDialpadUp() { + if (DEBUG) { + Log.d(TAG, "OnDialpadUp: isInSearchUi " + mActivityUi.isInSearchUi()); + } + if (mActivityUi.isInSearchUi()) { + slideActionBar(true /* slideUp */, true /* animate */); + } else { + // From the lists fragment + mSearchBox.fadeOut(mFadeOutCallback); + } + } + + public void slideActionBar(boolean slideUp, boolean animate) { + if (DEBUG) { + Log.d(TAG, "Sliding actionBar - up: " + slideUp + " animate: " + animate); + } + if (animate) { + ValueAnimator animator = slideUp ? ValueAnimator.ofFloat(0, 1) : ValueAnimator.ofFloat(1, 0); + animator.addUpdateListener( + new AnimatorUpdateListener() { + @Override + public void onAnimationUpdate(ValueAnimator animation) { + final float value = (float) animation.getAnimatedValue(); + setHideOffset((int) (mActivityUi.getActionBarHeight() * value)); + } + }); + animator.start(); + } else { + setHideOffset(slideUp ? mActivityUi.getActionBarHeight() : 0); + } + mIsActionBarSlidUp = slideUp; + } + + public void setAlpha(float alphaValue) { + mSearchBox.animate().alpha(alphaValue).start(); + } + + /** @return The offset the action bar is being translated upwards by */ + public int getHideOffset() { + return mActivityUi.getActionBarHideOffset(); + } + + public void setHideOffset(int offset) { + mIsActionBarSlidUp = offset >= mActivityUi.getActionBarHeight(); + mActivityUi.setActionBarHideOffset(offset); + } + + public int getActionBarHeight() { + return mActivityUi.getActionBarHeight(); + } + + /** Saves the current state of the action bar into a provided {@link Bundle} */ + public void saveInstanceState(Bundle outState) { + outState.putBoolean(KEY_IS_SLID_UP, mIsActionBarSlidUp); + outState.putBoolean(KEY_IS_FADED_OUT, mSearchBox.isFadedOut()); + outState.putBoolean(KEY_IS_EXPANDED, mSearchBox.isExpanded()); + } + + /** Restores the action bar state from a provided {@link Bundle}. */ + public void restoreInstanceState(Bundle inState) { + mIsActionBarSlidUp = inState.getBoolean(KEY_IS_SLID_UP); + + final boolean isSearchBoxFadedOut = inState.getBoolean(KEY_IS_FADED_OUT); + if (isSearchBoxFadedOut) { + if (!mSearchBox.isFadedOut()) { + mSearchBox.setVisible(false); + } + } else if (mSearchBox.isFadedOut()) { + mSearchBox.setVisible(true); + } + + final boolean isSearchBoxExpanded = inState.getBoolean(KEY_IS_EXPANDED); + if (isSearchBoxExpanded) { + if (!mSearchBox.isExpanded()) { + mSearchBox.expand(false, false); + } + } else if (mSearchBox.isExpanded()) { + mSearchBox.collapse(false); + } + } + + /** + * This should be called after onCreateOptionsMenu has been called, when the actionbar has been + * laid out and actually has a height. + */ + public void restoreActionBarOffset() { + slideActionBar(mIsActionBarSlidUp /* slideUp */, false /* animate */); + } + + @VisibleForTesting + public boolean getIsActionBarSlidUp() { + return mIsActionBarSlidUp; + } + + public interface ActivityUi { + + boolean isInSearchUi(); + + boolean hasSearchQuery(); + + boolean shouldShowActionBar(); + + int getActionBarHeight(); + + int getActionBarHideOffset(); + + void setActionBarHideOffset(int offset); + } +} diff --git a/java/com/android/dialer/app/widget/DialpadSearchEmptyContentView.java b/java/com/android/dialer/app/widget/DialpadSearchEmptyContentView.java new file mode 100644 index 000000000..85fd5ec6a --- /dev/null +++ b/java/com/android/dialer/app/widget/DialpadSearchEmptyContentView.java @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.dialer.app.widget; + +import android.content.Context; +import android.view.LayoutInflater; +import android.widget.LinearLayout; +import com.android.dialer.app.R; +import com.android.dialer.util.OrientationUtil; + +/** Empty content view to be shown when dialpad is visible. */ +public class DialpadSearchEmptyContentView extends EmptyContentView { + + public DialpadSearchEmptyContentView(Context context) { + super(context); + } + + @Override + protected void inflateLayout() { + int orientation = + OrientationUtil.isLandscape(getContext()) ? LinearLayout.HORIZONTAL : LinearLayout.VERTICAL; + + setOrientation(orientation); + + final LayoutInflater inflater = + (LayoutInflater) getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE); + inflater.inflate(R.layout.empty_content_view_dialpad_search, this); + } +} diff --git a/java/com/android/dialer/app/widget/EmptyContentView.java b/java/com/android/dialer/app/widget/EmptyContentView.java new file mode 100644 index 000000000..cfc8665a2 --- /dev/null +++ b/java/com/android/dialer/app/widget/EmptyContentView.java @@ -0,0 +1,121 @@ +/* + * Copyright (C) 2015 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.dialer.app.widget; + +import android.content.Context; +import android.util.AttributeSet; +import android.view.LayoutInflater; +import android.view.View; +import android.widget.ImageView; +import android.widget.LinearLayout; +import android.widget.TextView; +import com.android.dialer.app.R; + +public class EmptyContentView extends LinearLayout implements View.OnClickListener { + + /** Listener to call when action button is clicked. */ + public interface OnEmptyViewActionButtonClickedListener { + void onEmptyViewActionButtonClicked(); + } + + public static final int NO_LABEL = 0; + public static final int NO_IMAGE = 0; + + private ImageView mImageView; + private TextView mDescriptionView; + private TextView mActionView; + private OnEmptyViewActionButtonClickedListener mOnActionButtonClickedListener; + + public EmptyContentView(Context context) { + this(context, null); + } + + public EmptyContentView(Context context, AttributeSet attrs) { + this(context, attrs, 0); + } + + public EmptyContentView(Context context, AttributeSet attrs, int defStyleAttr) { + this(context, attrs, defStyleAttr, 0); + } + + public EmptyContentView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) { + super(context, attrs, defStyleAttr, defStyleRes); + inflateLayout(); + + // Don't let touches fall through the empty view. + setClickable(true); + mImageView = (ImageView) findViewById(R.id.emptyListViewImage); + mDescriptionView = (TextView) findViewById(R.id.emptyListViewMessage); + mActionView = (TextView) findViewById(R.id.emptyListViewAction); + mActionView.setOnClickListener(this); + } + + public void setDescription(int resourceId) { + if (resourceId == NO_LABEL) { + mDescriptionView.setText(null); + mDescriptionView.setVisibility(View.GONE); + } else { + mDescriptionView.setText(resourceId); + mDescriptionView.setVisibility(View.VISIBLE); + } + } + + public void setImage(int resourceId) { + if (resourceId == NO_LABEL) { + mImageView.setImageDrawable(null); + mImageView.setVisibility(View.GONE); + } else { + mImageView.setImageResource(resourceId); + mImageView.setVisibility(View.VISIBLE); + } + } + + public void setActionLabel(int resourceId) { + if (resourceId == NO_LABEL) { + mActionView.setText(null); + mActionView.setVisibility(View.GONE); + } else { + mActionView.setText(resourceId); + mActionView.setVisibility(View.VISIBLE); + } + } + + public boolean isShowingContent() { + return mImageView.getVisibility() == View.VISIBLE + || mDescriptionView.getVisibility() == View.VISIBLE + || mActionView.getVisibility() == View.VISIBLE; + } + + public void setActionClickedListener(OnEmptyViewActionButtonClickedListener listener) { + mOnActionButtonClickedListener = listener; + } + + @Override + public void onClick(View v) { + if (mOnActionButtonClickedListener != null) { + mOnActionButtonClickedListener.onEmptyViewActionButtonClicked(); + } + } + + protected void inflateLayout() { + setOrientation(LinearLayout.VERTICAL); + final LayoutInflater inflater = + (LayoutInflater) getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE); + inflater.inflate(R.layout.empty_content_view, this); + } + +} diff --git a/java/com/android/dialer/app/widget/SearchEditTextLayout.java b/java/com/android/dialer/app/widget/SearchEditTextLayout.java new file mode 100644 index 000000000..be850f9a0 --- /dev/null +++ b/java/com/android/dialer/app/widget/SearchEditTextLayout.java @@ -0,0 +1,324 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License + */ + +package com.android.dialer.app.widget; + +import android.animation.ValueAnimator; +import android.animation.ValueAnimator.AnimatorUpdateListener; +import android.content.Context; +import android.text.Editable; +import android.text.TextUtils; +import android.text.TextWatcher; +import android.util.AttributeSet; +import android.view.KeyEvent; +import android.view.View; +import android.widget.EditText; +import android.widget.FrameLayout; +import com.android.dialer.animation.AnimUtils; +import com.android.dialer.app.R; +import com.android.dialer.util.DialerUtils; + +public class SearchEditTextLayout extends FrameLayout { + + private static final float EXPAND_MARGIN_FRACTION_START = 0.8f; + private static final int ANIMATION_DURATION = 200; + /* Subclass-visible for testing */ + protected boolean mIsExpanded = false; + protected boolean mIsFadedOut = false; + private OnKeyListener mPreImeKeyListener; + private int mTopMargin; + private int mBottomMargin; + private int mLeftMargin; + private int mRightMargin; + private float mCollapsedElevation; + private View mCollapsed; + private View mExpanded; + private EditText mSearchView; + private View mSearchIcon; + private View mCollapsedSearchBox; + private View mVoiceSearchButtonView; + private View mOverflowButtonView; + private View mBackButtonView; + private View mExpandedSearchBox; + private View mClearButtonView; + + private ValueAnimator mAnimator; + + private Callback mCallback; + + public SearchEditTextLayout(Context context, AttributeSet attrs) { + super(context, attrs); + } + + public void setPreImeKeyListener(OnKeyListener listener) { + mPreImeKeyListener = listener; + } + + public void setCallback(Callback listener) { + mCallback = listener; + } + + @Override + protected void onFinishInflate() { + MarginLayoutParams params = (MarginLayoutParams) getLayoutParams(); + mTopMargin = params.topMargin; + mBottomMargin = params.bottomMargin; + mLeftMargin = params.leftMargin; + mRightMargin = params.rightMargin; + + mCollapsedElevation = getElevation(); + + mCollapsed = findViewById(R.id.search_box_collapsed); + mExpanded = findViewById(R.id.search_box_expanded); + mSearchView = (EditText) mExpanded.findViewById(R.id.search_view); + + mSearchIcon = findViewById(R.id.search_magnifying_glass); + mCollapsedSearchBox = findViewById(R.id.search_box_start_search); + mVoiceSearchButtonView = findViewById(R.id.voice_search_button); + mOverflowButtonView = findViewById(R.id.dialtacts_options_menu_button); + mBackButtonView = findViewById(R.id.search_back_button); + mExpandedSearchBox = findViewById(R.id.search_box_expanded); + mClearButtonView = findViewById(R.id.search_close_button); + + // Convert a long click into a click to expand the search box, and then long click on the + // search view. This accelerates the long-press scenario for copy/paste. + mCollapsedSearchBox.setOnLongClickListener( + new OnLongClickListener() { + @Override + public boolean onLongClick(View view) { + mCollapsedSearchBox.performClick(); + mSearchView.performLongClick(); + return false; + } + }); + + mSearchView.setOnFocusChangeListener( + new OnFocusChangeListener() { + @Override + public void onFocusChange(View v, boolean hasFocus) { + if (hasFocus) { + DialerUtils.showInputMethod(v); + } else { + DialerUtils.hideInputMethod(v); + } + } + }); + + mSearchView.setOnClickListener( + new View.OnClickListener() { + @Override + public void onClick(View v) { + if (mCallback != null) { + mCallback.onSearchViewClicked(); + } + } + }); + + mSearchView.addTextChangedListener( + new TextWatcher() { + @Override + public void beforeTextChanged(CharSequence s, int start, int count, int after) {} + + @Override + public void onTextChanged(CharSequence s, int start, int before, int count) { + mClearButtonView.setVisibility(TextUtils.isEmpty(s) ? View.GONE : View.VISIBLE); + } + + @Override + public void afterTextChanged(Editable s) {} + }); + + findViewById(R.id.search_close_button) + .setOnClickListener( + new OnClickListener() { + @Override + public void onClick(View v) { + mSearchView.setText(null); + } + }); + + findViewById(R.id.search_back_button) + .setOnClickListener( + new OnClickListener() { + @Override + public void onClick(View v) { + if (mCallback != null) { + mCallback.onBackButtonClicked(); + } + } + }); + + super.onFinishInflate(); + } + + @Override + public boolean dispatchKeyEventPreIme(KeyEvent event) { + if (mPreImeKeyListener != null) { + if (mPreImeKeyListener.onKey(this, event.getKeyCode(), event)) { + return true; + } + } + return super.dispatchKeyEventPreIme(event); + } + + public void fadeOut() { + fadeOut(null); + } + + public void fadeOut(AnimUtils.AnimationCallback callback) { + AnimUtils.fadeOut(this, ANIMATION_DURATION, callback); + mIsFadedOut = true; + } + + public void fadeIn() { + AnimUtils.fadeIn(this, ANIMATION_DURATION); + mIsFadedOut = false; + } + + public void setVisible(boolean visible) { + if (visible) { + setAlpha(1); + setVisibility(View.VISIBLE); + mIsFadedOut = false; + } else { + setAlpha(0); + setVisibility(View.GONE); + mIsFadedOut = true; + } + } + + public void expand(boolean animate, boolean requestFocus) { + updateVisibility(true /* isExpand */); + + if (animate) { + AnimUtils.crossFadeViews(mExpanded, mCollapsed, ANIMATION_DURATION); + mAnimator = ValueAnimator.ofFloat(EXPAND_MARGIN_FRACTION_START, 0f); + setMargins(EXPAND_MARGIN_FRACTION_START); + prepareAnimator(true); + } else { + mExpanded.setVisibility(View.VISIBLE); + mExpanded.setAlpha(1); + setMargins(0f); + mCollapsed.setVisibility(View.GONE); + } + + // Set 9-patch background. This owns the padding, so we need to restore the original values. + int paddingTop = this.getPaddingTop(); + int paddingStart = this.getPaddingStart(); + int paddingBottom = this.getPaddingBottom(); + int paddingEnd = this.getPaddingEnd(); + setBackgroundResource(R.drawable.search_shadow); + setElevation(0); + setPaddingRelative(paddingStart, paddingTop, paddingEnd, paddingBottom); + + if (requestFocus) { + mSearchView.requestFocus(); + } + mIsExpanded = true; + } + + public void collapse(boolean animate) { + updateVisibility(false /* isExpand */); + + if (animate) { + AnimUtils.crossFadeViews(mCollapsed, mExpanded, ANIMATION_DURATION); + mAnimator = ValueAnimator.ofFloat(0f, 1f); + prepareAnimator(false); + } else { + mCollapsed.setVisibility(View.VISIBLE); + mCollapsed.setAlpha(1); + setMargins(1f); + mExpanded.setVisibility(View.GONE); + } + + mIsExpanded = false; + setElevation(mCollapsedElevation); + setBackgroundResource(R.drawable.rounded_corner); + } + + /** + * Updates the visibility of views depending on whether we will show the expanded or collapsed + * search view. This helps prevent some jank with the crossfading if we are animating. + * + * @param isExpand Whether we are about to show the expanded search box. + */ + private void updateVisibility(boolean isExpand) { + int collapsedViewVisibility = isExpand ? View.GONE : View.VISIBLE; + int expandedViewVisibility = isExpand ? View.VISIBLE : View.GONE; + + mSearchIcon.setVisibility(collapsedViewVisibility); + mCollapsedSearchBox.setVisibility(collapsedViewVisibility); + mVoiceSearchButtonView.setVisibility(collapsedViewVisibility); + mOverflowButtonView.setVisibility(collapsedViewVisibility); + mBackButtonView.setVisibility(expandedViewVisibility); + // TODO: Prevents keyboard from jumping up in landscape mode after exiting the + // SearchFragment when the query string is empty. More elegant fix? + //mExpandedSearchBox.setVisibility(expandedViewVisibility); + if (TextUtils.isEmpty(mSearchView.getText())) { + mClearButtonView.setVisibility(View.GONE); + } else { + mClearButtonView.setVisibility(expandedViewVisibility); + } + } + + private void prepareAnimator(final boolean expand) { + if (mAnimator != null) { + mAnimator.cancel(); + } + + mAnimator.addUpdateListener( + new AnimatorUpdateListener() { + @Override + public void onAnimationUpdate(ValueAnimator animation) { + final Float fraction = (Float) animation.getAnimatedValue(); + setMargins(fraction); + } + }); + + mAnimator.setDuration(ANIMATION_DURATION); + mAnimator.start(); + } + + public boolean isExpanded() { + return mIsExpanded; + } + + public boolean isFadedOut() { + return mIsFadedOut; + } + + /** + * Assigns margins to the search box as a fraction of its maximum margin size + * + * @param fraction How large the margins should be as a fraction of their full size + */ + private void setMargins(float fraction) { + MarginLayoutParams params = (MarginLayoutParams) getLayoutParams(); + params.topMargin = (int) (mTopMargin * fraction); + params.bottomMargin = (int) (mBottomMargin * fraction); + params.leftMargin = (int) (mLeftMargin * fraction); + params.rightMargin = (int) (mRightMargin * fraction); + requestLayout(); + } + + /** Listener for the back button next to the search view being pressed */ + public interface Callback { + + void onBackButtonClicked(); + + void onSearchViewClicked(); + } +} |