| // Copyright 2016 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| package org.chromium.chrome.browser.compositor.bottombar; |
| |
| import android.content.Context; |
| import android.graphics.Color; |
| import android.view.ViewGroup; |
| |
| import org.chromium.base.ApiCompatibilityUtils; |
| import org.chromium.base.VisibleForTesting; |
| import org.chromium.chrome.R; |
| import org.chromium.chrome.browser.compositor.bottombar.OverlayPanel.PanelState; |
| import org.chromium.chrome.browser.compositor.bottombar.OverlayPanel.StateChangeReason; |
| import org.chromium.chrome.browser.util.MathUtils; |
| import org.chromium.ui.base.LocalizationUtils; |
| import org.chromium.ui.resources.dynamics.DynamicResourceLoader; |
| |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.Map; |
| |
| /** |
| * Base abstract class for the Overlay Panel. |
| */ |
| abstract class OverlayPanelBase { |
| /** The side padding of Bar icons in dps. */ |
| private static final float BAR_ICON_SIDE_PADDING_DP = 12.f; |
| |
| /** The height of the Bar's border in dps. */ |
| private static final float BAR_BORDER_HEIGHT_DP = 1.f; |
| |
| /** The height of the expanded Overlay Panel relative to the height of the screen. */ |
| private static final float EXPANDED_PANEL_HEIGHT_PERCENTAGE = .7f; |
| |
| /** The width of the small version of the Overlay Panel in dps. */ |
| private static final float SMALL_PANEL_WIDTH_DP = 600.f; |
| |
| /** |
| * The minimum width a screen should have in order to trigger the small version of the Panel. |
| */ |
| private static final float SMALL_PANEL_WIDTH_THRESHOLD_DP = 680.f; |
| |
| /** The brightness of the base page when the Panel is peeking. */ |
| private static final float BASE_PAGE_BRIGHTNESS_STATE_PEEKED = 1.f; |
| |
| /** The brightness of the base page when the Panel is expanded. */ |
| private static final float BASE_PAGE_BRIGHTNESS_STATE_EXPANDED = .7f; |
| |
| /** |
| * The brightness of the base page when the Panel is maximized. This value matches the alert |
| * dialog brightness filter. |
| */ |
| private static final float BASE_PAGE_BRIGHTNESS_STATE_MAXIMIZED = .4f; |
| |
| /** The opacity of the arrow icon when the Panel is peeking. */ |
| private static final float ARROW_ICON_OPACITY_STATE_PEEKED = 1.f; |
| |
| /** The opacity of the arrow icon when the Panel is expanded. */ |
| private static final float ARROW_ICON_OPACITY_STATE_EXPANDED = 0.f; |
| |
| /** The opacity of the arrow icon when the Panel is maximized. */ |
| private static final float ARROW_ICON_OPACITY_STATE_MAXIMIZED = 0.f; |
| |
| /** The rotation of the arrow icon. */ |
| private static final float ARROW_ICON_ROTATION = -90.f; |
| |
| /** The opacity of the close icon when the Panel is peeking. */ |
| private static final float CLOSE_ICON_OPACITY_STATE_PEEKED = 0.f; |
| |
| /** The opacity of the close icon when the Panel is expanded. */ |
| private static final float CLOSE_ICON_OPACITY_STATE_EXPANDED = 1.f; |
| |
| /** The opacity of the close icon when the Panel is maximized. */ |
| private static final float CLOSE_ICON_OPACITY_STATE_MAXIMIZED = 1.f; |
| |
| /** The id of the close icon drawable. */ |
| public static final int CLOSE_ICON_DRAWABLE_ID = R.drawable.btn_close; |
| |
| /** The height of the Progress Bar in dps. */ |
| private static final float PROGRESS_BAR_HEIGHT_DP = 2.f; |
| |
| /** |
| * The distance from the Progress Bar must be away from the bottom of the |
| * screen in order to be completely visible. The closer the Progress Bar |
| * gets to the bottom of the screen, the lower its opacity will be. When the |
| * Progress Bar is at the very bottom of the screen (when the Overlay Panel |
| * is peeking) it will be completely invisible. |
| */ |
| private static final float PROGRESS_BAR_VISIBILITY_THRESHOLD_DP = 10.f; |
| |
| /** The height of the Toolbar in dps. */ |
| private float mToolbarHeight; |
| |
| /** The height of the Bar when the Panel is peeking, in dps. */ |
| private float mBarHeightPeeking; |
| |
| /** The height of the Bar when the Panel is expanded, in dps. */ |
| private float mBarHeightExpanded; |
| |
| /** The height of the Bar when the Panel is maximized, in dps. */ |
| private float mBarHeightMaximized; |
| |
| /** Ratio of dps per pixel. */ |
| protected float mPxToDp; |
| |
| /** |
| * The Y coordinate to apply to the Base Page in order to keep the selection |
| * in view when the Overlay Panel is in its EXPANDED state. |
| */ |
| private float mBasePageTargetY = 0.f; |
| |
| /** The current context. */ |
| protected final Context mContext; |
| |
| /** The current state of the Overlay Panel. */ |
| private PanelState mPanelState = PanelState.UNDEFINED; |
| |
| /** |
| * Valid previous states for the Panel. |
| */ |
| protected static final Map<PanelState, PanelState> PREVIOUS_STATES; |
| static { |
| Map<PanelState, PanelState> states = new HashMap<>(); |
| // Pairs are of the form <Current, Previous>. |
| states.put(PanelState.PEEKED, PanelState.CLOSED); |
| states.put(PanelState.EXPANDED, PanelState.PEEKED); |
| states.put(PanelState.MAXIMIZED, PanelState.EXPANDED); |
| PREVIOUS_STATES = Collections.unmodifiableMap(states); |
| } |
| |
| // ============================================================================================ |
| // Constructor |
| // ============================================================================================ |
| |
| /** |
| * @param context The current Android {@link Context}. |
| */ |
| public OverlayPanelBase(Context context) { |
| mContext = context; |
| } |
| |
| // ============================================================================================ |
| // General API |
| // ============================================================================================ |
| |
| /** |
| * Animates the Overlay Panel to its closed state. |
| * @param reason The reason for the change of panel state. |
| * @param animate If the panel should animate closed. |
| */ |
| protected abstract void closePanel(StateChangeReason reason, boolean animate); |
| |
| /** |
| * Event notification that the Panel did get closed. |
| * @param reason The reason the panel is closing. |
| */ |
| protected abstract void onClosed(StateChangeReason reason); |
| |
| /** |
| * TODO(mdjones): This method should be removed from this class. |
| * @return The resource id that contains how large the top controls are. |
| */ |
| protected abstract int getControlContainerHeightResource(); |
| |
| /** |
| * Handles when the Panel's container view size changes. |
| * @param width The new width of the Panel's container view. |
| * @param height The new height of the Panel's container view. |
| * @param previousWidth The previous width of the Panel's container view. |
| */ |
| protected abstract void handleSizeChanged(float width, float height, float previousWidth); |
| |
| // ============================================================================================ |
| // Layout Integration |
| // ============================================================================================ |
| |
| private float mLayoutWidth; |
| private float mLayoutHeight; |
| private float mLayoutYOffset; |
| |
| private float mMaximumWidth; |
| private float mMaximumHeight; |
| |
| private boolean mIsFullWidthSizePanelForTesting; |
| private boolean mOverrideIsFullWidthSizePanelForTesting; |
| |
| /** |
| * Called when the layout has changed. |
| * |
| * @param width The new width in dp. |
| * @param height The new height in dp. |
| * @param visibleViewportOffsetY The Y offset of the content in dp. |
| */ |
| public void onLayoutChanged(float width, float height, float visibleViewportOffsetY) { |
| if (width == mLayoutWidth && height == mLayoutHeight |
| && visibleViewportOffsetY == mLayoutYOffset) { |
| return; |
| } |
| |
| float previousLayoutWidth = mLayoutWidth; |
| |
| mLayoutWidth = width; |
| mLayoutHeight = height; |
| mLayoutYOffset = visibleViewportOffsetY; |
| |
| mMaximumWidth = calculateOverlayPanelWidth(); |
| mMaximumHeight = getPanelHeightFromState(PanelState.MAXIMIZED); |
| |
| handleSizeChanged(width, height, previousLayoutWidth); |
| } |
| |
| /** |
| * @return Whether the Panel is in full width size. |
| */ |
| protected boolean isFullWidthSizePanel() { |
| return doesMatchFullWidthCriteria(getFullscreenWidth()); |
| } |
| |
| /** |
| * @param containerWidth The width of the panel's container. |
| * @return Whether the given width matches the criteria required for a full width Panel. |
| */ |
| protected boolean doesMatchFullWidthCriteria(float containerWidth) { |
| if (mOverrideIsFullWidthSizePanelForTesting) { |
| return mIsFullWidthSizePanelForTesting; |
| } |
| return containerWidth <= SMALL_PANEL_WIDTH_THRESHOLD_DP; |
| } |
| |
| /** |
| * @return The current X-position of the Overlay Panel. |
| */ |
| protected float calculateOverlayPanelX() { |
| return isFullWidthSizePanel() ? 0.f |
| : Math.round((getFullscreenWidth() - calculateOverlayPanelWidth()) / 2.f); |
| } |
| |
| /** |
| * @return The current Y-position of the Overlay Panel. |
| */ |
| protected float calculateOverlayPanelY() { |
| return getTabHeight() - mHeight; |
| } |
| |
| /** |
| * @return The current width of the Overlay Panel. |
| */ |
| protected float calculateOverlayPanelWidth() { |
| return isFullWidthSizePanel() ? getFullscreenWidth() : SMALL_PANEL_WIDTH_DP; |
| } |
| |
| /** |
| * @return The height of the Chrome toolbar in dp. |
| */ |
| public float getToolbarHeight() { |
| return mToolbarHeight; |
| } |
| |
| /** |
| * @return Whether the Panel is showing. |
| */ |
| public boolean isShowing() { |
| return mHeight > 0; |
| } |
| |
| /** |
| * @return Whether the Overlay Panel is opened. That is, whether the current height is greater |
| * than the peeking height. |
| */ |
| public boolean isPanelOpened() { |
| return mHeight > getBarContainerHeight(); |
| } |
| |
| /** |
| * @return The fullscreen width. |
| */ |
| private float getFullscreenWidth() { |
| return mLayoutWidth; |
| } |
| |
| /** |
| * @return The height of the tab the panel is displayed on top of. |
| */ |
| public float getTabHeight() { |
| return mLayoutHeight; |
| } |
| |
| /** |
| * @return The maximum width of the Overlay Panel in pixels. |
| */ |
| public int getMaximumWidthPx() { |
| return Math.round(mMaximumWidth / mPxToDp); |
| } |
| |
| /** |
| * The Panel Bar Container is a abstract container that groups the Controls |
| * that will be visible when the Panel is in the peeked state. |
| * |
| * @return The Panel Bar Container in dps. |
| */ |
| public float getBarContainerHeight() { |
| return getBarHeight(); |
| } |
| |
| /** |
| * @return The width of the Overlay Panel Content View in pixels. |
| */ |
| public int getContentViewWidthPx() { |
| return getMaximumWidthPx(); |
| } |
| |
| /** |
| * @return The height of the Overlay Panel Content View in pixels. |
| */ |
| public int getContentViewHeightPx() { |
| float barExpandedHeight = isFullWidthSizePanel() |
| ? getToolbarHeight() : mBarHeightPeeking; |
| return Math.round((mMaximumHeight - barExpandedHeight) / mPxToDp); |
| } |
| |
| // ============================================================================================ |
| // UI States |
| // ============================================================================================ |
| |
| // -------------------------------------------------------------------------------------------- |
| // Overlay Panel states |
| // -------------------------------------------------------------------------------------------- |
| |
| private float mOffsetX; |
| private float mOffsetY; |
| private float mHeight; |
| private boolean mIsMaximized; |
| |
| /** |
| * @return The vertical offset of the Overlay Panel. |
| */ |
| public float getOffsetX() { |
| return mOffsetX; |
| } |
| |
| /** |
| * @return The vertical offset of the Overlay Panel. |
| */ |
| public float getOffsetY() { |
| return mOffsetY; |
| } |
| |
| /** |
| * @return The width of the Overlay Panel in dps. |
| */ |
| public float getWidth() { |
| return mMaximumWidth; |
| } |
| |
| /** |
| * @return The height of the Overlay Panel in dps. |
| */ |
| public float getHeight() { |
| return mHeight; |
| } |
| |
| /** |
| * @return Whether the Overlay Panel is fully maximized. |
| */ |
| public boolean isMaximized() { |
| return mIsMaximized; |
| } |
| |
| // -------------------------------------------------------------------------------------------- |
| // Panel Bar states |
| // -------------------------------------------------------------------------------------------- |
| private float mBarMarginSide; |
| private float mBarHeight; |
| private boolean mIsBarBorderVisible; |
| private float mBarBorderHeight; |
| |
| private boolean mBarShadowVisible = false; |
| private float mBarShadowOpacity = 0.f; |
| |
| private float mArrowIconOpacity; |
| |
| private float mCloseIconOpacity; |
| private float mCloseIconWidth; |
| |
| /** |
| * @return The side margin of the Bar. |
| */ |
| public float getBarMarginSide() { |
| return mBarMarginSide; |
| } |
| |
| /** |
| * @return The height of the Bar. |
| */ |
| public float getBarHeight() { |
| return mBarHeight; |
| } |
| |
| /** |
| * @return Whether the Bar border is visible. |
| */ |
| public boolean isBarBorderVisible() { |
| return mIsBarBorderVisible; |
| } |
| |
| /** |
| * @return The height of the Bar border. |
| */ |
| public float getBarBorderHeight() { |
| return mBarBorderHeight; |
| } |
| |
| /** |
| * @return Whether the Bar shadow is visible. |
| */ |
| public boolean getBarShadowVisible() { |
| return mBarShadowVisible; |
| } |
| |
| /** |
| * @return The opacity of the Bar shadow. |
| */ |
| public float getBarShadowOpacity() { |
| return mBarShadowOpacity; |
| } |
| |
| /** |
| * @return The opacity of the arrow icon. |
| */ |
| public float getArrowIconOpacity() { |
| return mArrowIconOpacity; |
| } |
| |
| /** |
| * @return The rotation of the arrow icon, in degrees. |
| */ |
| public float getArrowIconRotation() { |
| return ARROW_ICON_ROTATION; |
| } |
| |
| /** |
| * @return The opacity of the close icon. |
| */ |
| public float getCloseIconOpacity() { |
| return mCloseIconOpacity; |
| } |
| |
| /** |
| * @return The width/height of the close icon. |
| */ |
| public float getCloseIconDimension() { |
| if (mCloseIconWidth == 0) { |
| mCloseIconWidth = ApiCompatibilityUtils.getDrawable(mContext.getResources(), |
| CLOSE_ICON_DRAWABLE_ID).getIntrinsicWidth() * mPxToDp; |
| } |
| return mCloseIconWidth; |
| } |
| |
| /** |
| * @return The left X coordinate of the close icon. |
| */ |
| public float getCloseIconX() { |
| if (LocalizationUtils.isLayoutRtl()) { |
| return getOffsetX() + getBarMarginSide(); |
| } else { |
| return getOffsetX() + getWidth() - getBarMarginSide() - getCloseIconDimension(); |
| } |
| } |
| |
| // -------------------------------------------------------------------------------------------- |
| // Base Page states |
| // -------------------------------------------------------------------------------------------- |
| |
| private float mBasePageY = 0.0f; |
| private float mBasePageBrightness = 1.0f; |
| |
| /** |
| * @return The vertical offset of the base page. |
| */ |
| public float getBasePageY() { |
| return mBasePageY; |
| } |
| |
| /** |
| * @return The brightness of the base page. |
| */ |
| public float getBasePageBrightness() { |
| return mBasePageBrightness; |
| } |
| |
| /** |
| * @return The color to fill the base page when viewport is resized/changes orientation. |
| */ |
| public int getBasePageBackgroundColor() { |
| // TODO(pedrosimonetti): Get the color from the CVC and apply a proper brightness transform. |
| // NOTE(pedrosimonetti): Assumes the background color of the base page to be white (255) |
| // and applies a simple brightness transformation based on the base page value. |
| int value = Math.round(255 * mBasePageBrightness); |
| value = MathUtils.clamp(value, 0, 255); |
| return Color.rgb(value, value, value); |
| } |
| |
| // -------------------------------------------------------------------------------------------- |
| // Progress Bar states |
| // -------------------------------------------------------------------------------------------- |
| |
| private float mProgressBarOpacity; |
| private boolean mIsProgressBarVisible; |
| private float mProgressBarHeight; |
| private int mProgressBarCompletion; |
| |
| /** |
| * @return Whether the Progress Bar is visible. |
| */ |
| public boolean isProgressBarVisible() { |
| return mIsProgressBarVisible; |
| } |
| |
| /** |
| * @param isVisible Whether the Progress Bar should be visible. |
| */ |
| protected void setProgressBarVisible(boolean isVisible) { |
| mIsProgressBarVisible = isVisible; |
| } |
| |
| /** |
| * @return The Progress Bar height. |
| */ |
| public float getProgressBarHeight() { |
| return mProgressBarHeight; |
| } |
| |
| /** |
| * @return The Progress Bar opacity. |
| */ |
| public float getProgressBarOpacity() { |
| return mProgressBarOpacity; |
| } |
| |
| /** |
| * @return The completion percentage of the Progress Bar. |
| */ |
| public int getProgressBarCompletion() { |
| return mProgressBarCompletion; |
| } |
| |
| /** |
| * @param completion The completion percentage to be set. |
| */ |
| protected void setProgressBarCompletion(int completion) { |
| mProgressBarCompletion = completion; |
| } |
| |
| // ============================================================================================ |
| // State Handler |
| // ============================================================================================ |
| |
| /** |
| * @return The panel's state. |
| */ |
| public PanelState getPanelState() { |
| return mPanelState; |
| } |
| |
| /** |
| * Sets the panel's state. |
| * @param state The panel state to transition to. |
| * @param reason The reason for a change in the panel's state. |
| */ |
| protected void setPanelState(PanelState state, StateChangeReason reason) { |
| if (state == PanelState.CLOSED) { |
| mHeight = 0; |
| onClosed(reason); |
| } |
| |
| // We should only set the state at the end of this method, in oder to make sure that |
| // all callbacks will be fired before changing the state of the Panel. This prevents |
| // some flakiness on tests since they rely on changes of state to determine when a |
| // particular action has been completed. |
| mPanelState = state; |
| } |
| |
| /** |
| * Determines if a given {@code PanelState} is supported by the Panel. By default, |
| * all states are supported, but subclasses can override this class to inform |
| * custom supported states. |
| * @param state A given state. |
| * @return Whether the panel supports a given state. |
| */ |
| protected boolean isSupportedState(PanelState state) { |
| return true; |
| } |
| |
| /** |
| * Determines if a given {@code PanelState} is a valid UI state. The UNDEFINED state |
| * should never be considered a valid UI state. |
| * @param state The given state. |
| * @return Whether the state is valid. |
| */ |
| private boolean isValidUiState(PanelState state) { |
| // TODO(pedrosimonetti): consider removing the UNDEFINED state |
| // which would allow removing this method. |
| return isSupportedState(state) && state != PanelState.UNDEFINED; |
| } |
| |
| /** |
| * @return The maximum state supported by the panel. |
| */ |
| private PanelState getMaximumSupportedState() { |
| if (isSupportedState(PanelState.MAXIMIZED)) { |
| return PanelState.MAXIMIZED; |
| } else if (isSupportedState(PanelState.EXPANDED)) { |
| return PanelState.EXPANDED; |
| } else { |
| return PanelState.PEEKED; |
| } |
| } |
| |
| /** |
| * @return The {@code PanelState} that is before the |state| in the order of states. |
| */ |
| private PanelState getPreviousPanelState(PanelState state) { |
| PanelState prevState = PREVIOUS_STATES.get(state); |
| if (!isSupportedState(PanelState.EXPANDED)) { |
| prevState = PREVIOUS_STATES.get(prevState); |
| } |
| return prevState != null ? prevState : PanelState.UNDEFINED; |
| } |
| |
| // ============================================================================================ |
| // Helpers |
| // ============================================================================================ |
| |
| /** |
| * Gets the height of the Overlay Panel in dps for a given |state|. |
| * |
| * @param state The state whose height will be calculated. |
| * @return The height of the Overlay Panel in dps for a given |state|. |
| */ |
| public float getPanelHeightFromState(PanelState state) { |
| if (state == PanelState.PEEKED) { |
| return getPeekedHeight(); |
| } else if (state == PanelState.EXPANDED) { |
| return getExpandedHeight(); |
| } else if (state == PanelState.MAXIMIZED) { |
| return getMaximizedHeight(); |
| } |
| return 0; |
| } |
| |
| /** |
| * @return The peeked height of the panel in dps. |
| */ |
| protected float getPeekedHeight() { |
| return mBarHeightPeeking; |
| } |
| |
| /** |
| * @return The expanded height of the panel in dps. |
| */ |
| protected float getExpandedHeight() { |
| if (isFullWidthSizePanel()) { |
| return getTabHeight() * EXPANDED_PANEL_HEIGHT_PERCENTAGE; |
| } else { |
| return (getTabHeight() - mToolbarHeight) * EXPANDED_PANEL_HEIGHT_PERCENTAGE; |
| } |
| } |
| |
| /** |
| * @return The maximized height of the panel in dps. |
| */ |
| protected float getMaximizedHeight() { |
| if (isFullWidthSizePanel()) { |
| return getTabHeight(); |
| } else { |
| return getTabHeight() - mToolbarHeight; |
| } |
| } |
| |
| /** |
| * Initializes the UI state. |
| */ |
| protected void initializeUiState() { |
| mPxToDp = 1.f / mContext.getResources().getDisplayMetrics().density; |
| |
| mToolbarHeight = mContext.getResources().getDimension( |
| getControlContainerHeightResource()) * mPxToDp; |
| |
| mBarHeightPeeking = mContext.getResources().getDimension( |
| R.dimen.overlay_panel_bar_height) * mPxToDp; |
| mBarHeightMaximized = mContext.getResources().getDimension( |
| R.dimen.toolbar_height_no_shadow) * mPxToDp; |
| mBarHeightExpanded = |
| Math.round((mBarHeightPeeking + mBarHeightMaximized) / 2.f); |
| |
| mBarMarginSide = BAR_ICON_SIDE_PADDING_DP; |
| mProgressBarHeight = PROGRESS_BAR_HEIGHT_DP; |
| mBarBorderHeight = BAR_BORDER_HEIGHT_DP; |
| |
| mBarHeight = mBarHeightPeeking; |
| } |
| |
| /** |
| * @return The fraction of the distance the panel has to be to its next state before animating |
| * itself there. Default is the panel must be half of the way to the next state. |
| */ |
| protected float getThresholdToNextState() { |
| return 0.5f; |
| } |
| |
| /** |
| * Finds the state which has the nearest height compared to a given |
| * |desiredPanelHeight|. |
| * |
| * @param desiredPanelHeight The height to compare to. |
| * @param velocity The velocity of the swipe if applicable. The swipe is upward if less than 0. |
| * @return The nearest panel state. |
| */ |
| protected PanelState findNearestPanelStateFromHeight(float desiredPanelHeight, float velocity) { |
| // If the panel was flung hard enough to make the desired height negative, it's closed. |
| if (desiredPanelHeight < 0) return PanelState.CLOSED; |
| |
| // First, find the two states that the desired panel height is between. |
| PanelState nextState = PanelState.values()[0]; |
| PanelState prevState = nextState; |
| for (PanelState state : PanelState.values()) { |
| if (!isValidUiState(state)) { |
| continue; |
| } |
| prevState = nextState; |
| nextState = state; |
| // The values in PanelState are ascending, they should be kept that way in order for |
| // this to work. |
| if (desiredPanelHeight >= getPanelHeightFromState(prevState) |
| && desiredPanelHeight < getPanelHeightFromState(nextState)) { |
| break; |
| } |
| } |
| |
| // If the desired height is close enough to a certain state, depending on the direction of |
| // the velocity, move to that state. |
| float lowerBound = getPanelHeightFromState(prevState); |
| float distance = getPanelHeightFromState(nextState) - lowerBound; |
| float thresholdToNextState = velocity < 0.0f |
| ? getThresholdToNextState() : 1.0f - getThresholdToNextState(); |
| if ((desiredPanelHeight - lowerBound) / distance > thresholdToNextState) { |
| return nextState; |
| } else { |
| return prevState; |
| } |
| } |
| |
| /** |
| * Sets the last panel height within the limits allowable by our UI. |
| * |
| * @param height The height of the panel in dps. |
| */ |
| protected void setClampedPanelHeight(float height) { |
| final float clampedHeight = MathUtils.clamp(height, |
| getPanelHeightFromState(getMaximumSupportedState()), |
| getPanelHeightFromState(PanelState.PEEKED)); |
| setPanelHeight(clampedHeight); |
| } |
| |
| /** |
| * Sets the panel height. |
| * |
| * @param height The height of the panel in dps. |
| */ |
| protected void setPanelHeight(float height) { |
| updatePanelForHeight(height); |
| } |
| |
| /** |
| * @param state The Panel state. |
| * @return Whether the Panel height matches the one from the given state. |
| */ |
| protected boolean doesPanelHeightMatchState(PanelState state) { |
| return state == getPanelState() && getHeight() == getPanelHeightFromState(state); |
| } |
| |
| // ============================================================================================ |
| // UI Update Handling |
| // ============================================================================================ |
| |
| /** |
| * Updates the UI state for a given |height|. |
| * |
| * @param height The Overlay Panel height. |
| */ |
| private void updatePanelForHeight(float height) { |
| PanelState endState = findLargestPanelStateFromHeight(height); |
| PanelState startState = getPreviousPanelState(endState); |
| float percentage = getStateCompletion(height, startState, endState); |
| |
| updatePanelSize(height); |
| |
| if (endState == PanelState.CLOSED || endState == PanelState.PEEKED) { |
| updatePanelForCloseOrPeek(percentage); |
| } else if (endState == PanelState.EXPANDED) { |
| updatePanelForExpansion(percentage); |
| } else if (endState == PanelState.MAXIMIZED) { |
| updatePanelForMaximization(percentage); |
| } |
| } |
| |
| /** |
| * Updates the Panel size information. |
| * |
| * @param height The Overlay Panel height. |
| */ |
| private void updatePanelSize(float height) { |
| mHeight = height; |
| mOffsetX = calculateOverlayPanelX(); |
| mOffsetY = calculateOverlayPanelY(); |
| mIsMaximized = height == getPanelHeightFromState(PanelState.MAXIMIZED); |
| } |
| |
| /** |
| * Finds the largest Panel state which is being transitioned to/from. |
| * Whenever the Panel is in between states, let's say, when resizing the |
| * Panel from its peeked to expanded state, we need to know those two states |
| * in order to calculate how closely we are from one of them. This method |
| * will always return the nearest state with the largest height, and |
| * together with the state preceding it, it's possible to calculate how far |
| * the Panel is from them. |
| * |
| * @param panelHeight The height to compare to. |
| * @return The panel state which is being transitioned to/from. |
| */ |
| private PanelState findLargestPanelStateFromHeight(float panelHeight) { |
| PanelState stateFound = PanelState.CLOSED; |
| |
| // Iterate over all states and find the largest one which is being |
| // transitioned to/from. |
| for (PanelState state : PanelState.values()) { |
| if (!isValidUiState(state)) { |
| continue; |
| } |
| if (panelHeight <= getPanelHeightFromState(state)) { |
| stateFound = state; |
| break; |
| } |
| } |
| |
| return stateFound; |
| } |
| |
| /** |
| * Gets the state completion percentage, taking into consideration the |height| of the Overlay |
| * Panel, and the initial and final states. A completion of 0 means the Panel is in the initial |
| * state and a completion of 1 means the Panel is in the final state. |
| * |
| * @param height The height of the Overlay Panel. |
| * @param startState The initial state of the Panel. |
| * @param endState The final state of the Panel. |
| * @return The completion percentage. |
| */ |
| private float getStateCompletion(float height, PanelState startState, PanelState endState) { |
| float startSize = getPanelHeightFromState(startState); |
| float endSize = getPanelHeightFromState(endState); |
| // NOTE(pedrosimonetti): Handle special case from PanelState.UNDEFINED |
| // to PanelState.CLOSED, where both have a height of zero. Returning |
| // zero here means the Panel will be reset to its CLOSED state. |
| return startSize == 0.f && endSize == 0.f ? 0.f |
| : (height - startSize) / (endSize - startSize); |
| } |
| |
| /** |
| * Updates the UI state for the closed to peeked transition (and vice |
| * versa), according to a completion |percentage|. |
| * |
| * @param percentage The completion percentage. |
| */ |
| protected void updatePanelForCloseOrPeek(float percentage) { |
| // Base page offset. |
| mBasePageY = 0.f; |
| |
| // Base page brightness. |
| mBasePageBrightness = BASE_PAGE_BRIGHTNESS_STATE_PEEKED; |
| |
| // Bar height. |
| mBarHeight = mBarHeightPeeking; |
| |
| // Bar border. |
| mIsBarBorderVisible = false; |
| |
| // Arrow Icon. |
| mArrowIconOpacity = ARROW_ICON_OPACITY_STATE_PEEKED; |
| |
| // Close icon opacity. |
| mCloseIconOpacity = CLOSE_ICON_OPACITY_STATE_PEEKED; |
| |
| // Progress Bar. |
| mProgressBarOpacity = 0.f; |
| |
| // Update the Bar Shadow. |
| updateBarShadow(); |
| } |
| |
| /** |
| * Updates the UI state for the peeked to expanded transition (and vice |
| * versa), according to a completion |percentage|. |
| * |
| * @param percentage The completion percentage. |
| */ |
| protected void updatePanelForExpansion(float percentage) { |
| // Base page offset. |
| mBasePageY = MathUtils.interpolate( |
| 0.f, |
| getBasePageTargetY(), |
| percentage); |
| |
| // Base page brightness. |
| mBasePageBrightness = MathUtils.interpolate( |
| BASE_PAGE_BRIGHTNESS_STATE_PEEKED, |
| BASE_PAGE_BRIGHTNESS_STATE_EXPANDED, |
| percentage); |
| |
| // Bar height. |
| mBarHeight = Math.round(MathUtils.interpolate( |
| mBarHeightPeeking, |
| getBarHeightExpanded(), |
| percentage)); |
| |
| // Bar border. |
| mIsBarBorderVisible = true; |
| |
| // Determine fading element opacities. The arrow icon needs to finish fading out before |
| // the close icon starts fading in. Any other elements fading in or fading out should use |
| // the same percentage. |
| float fadingOutPercentage = Math.min(percentage, .5f) / .5f; |
| float fadingInPercentage = Math.max(percentage - .5f, 0.f) / .5f; |
| |
| // Arrow Icon. |
| mArrowIconOpacity = MathUtils.interpolate( |
| ARROW_ICON_OPACITY_STATE_PEEKED, |
| ARROW_ICON_OPACITY_STATE_EXPANDED, |
| fadingOutPercentage); |
| |
| // Close Icon. |
| mCloseIconOpacity = MathUtils.interpolate( |
| CLOSE_ICON_OPACITY_STATE_PEEKED, |
| CLOSE_ICON_OPACITY_STATE_EXPANDED, |
| fadingInPercentage); |
| |
| // Progress Bar. |
| float peekedHeight = getPanelHeightFromState(PanelState.PEEKED); |
| float threshold = PROGRESS_BAR_VISIBILITY_THRESHOLD_DP / mPxToDp; |
| float diff = Math.min(mHeight - peekedHeight, threshold); |
| // Fades the Progress Bar the closer it gets to the bottom of the |
| // screen. |
| mProgressBarOpacity = MathUtils.interpolate(0.f, 1.f, diff / threshold); |
| |
| // Update the Bar Shadow. |
| updateBarShadow(); |
| } |
| |
| /** |
| * Updates the UI state for the expanded to maximized transition (and vice |
| * versa), according to a completion |percentage|. |
| * |
| * @param percentage The completion percentage. |
| */ |
| protected void updatePanelForMaximization(float percentage) { |
| boolean supportsExpandedState = isSupportedState(PanelState.EXPANDED); |
| |
| // Base page offset. |
| float startTargetY = supportsExpandedState ? getBasePageTargetY() : 0.0f; |
| mBasePageY = MathUtils.interpolate( |
| startTargetY, |
| getBasePageTargetY(), |
| percentage); |
| |
| // Base page brightness. |
| float startBrightness = supportsExpandedState |
| ? BASE_PAGE_BRIGHTNESS_STATE_EXPANDED : BASE_PAGE_BRIGHTNESS_STATE_PEEKED; |
| mBasePageBrightness = MathUtils.interpolate( |
| startBrightness, |
| BASE_PAGE_BRIGHTNESS_STATE_MAXIMIZED, |
| percentage); |
| |
| // Bar height. |
| float startBarHeight = supportsExpandedState |
| ? getBarHeightExpanded() : getBarHeightPeeking(); |
| mBarHeight = Math.round(MathUtils.interpolate( |
| startBarHeight, |
| getBarHeightMaximized(), |
| percentage)); |
| |
| // Bar border. |
| mIsBarBorderVisible = true; |
| |
| // Arrow Icon. |
| mArrowIconOpacity = ARROW_ICON_OPACITY_STATE_MAXIMIZED; |
| |
| // Close Icon. |
| mCloseIconOpacity = CLOSE_ICON_OPACITY_STATE_MAXIMIZED; |
| |
| // Progress Bar. |
| mProgressBarOpacity = 1.f; |
| |
| // Update the Bar Shadow. |
| updateBarShadow(); |
| } |
| |
| private float getBarHeightExpanded() { |
| if (isFullWidthSizePanel()) { |
| return mBarHeightExpanded; |
| } else { |
| return mBarHeightPeeking; |
| } |
| } |
| |
| private float getBarHeightMaximized() { |
| if (isFullWidthSizePanel()) { |
| return mBarHeightMaximized; |
| } else { |
| return mBarHeightPeeking; |
| } |
| } |
| |
| /** |
| * @return The peeking height of the panel's bar in dp. |
| */ |
| protected float getBarHeightPeeking() { |
| return mBarHeightPeeking; |
| } |
| |
| /** |
| * Updates the UI state for Bar Shadow. |
| */ |
| protected void updateBarShadow() { |
| float barShadowOpacity = calculateBarShadowOpacity(); |
| |
| if (barShadowOpacity > 0.f) { |
| mBarShadowVisible = true; |
| mBarShadowOpacity = barShadowOpacity; |
| } else { |
| mBarShadowVisible = false; |
| mBarShadowOpacity = 0.f; |
| } |
| } |
| |
| /** |
| * @return The new opacity value for the Bar Shadow. |
| */ |
| protected float calculateBarShadowOpacity() { |
| return 0.f; |
| } |
| |
| // ============================================================================================ |
| // Base Page Offset |
| // ============================================================================================ |
| |
| /** |
| * Calculates the desired offset for the Base Page. The purpose of this method is to allow |
| * subclasses to provide an specific offset, which can be useful for keeping a certain |
| * portion of the Base Page visible when a Panel is in expanded state. To facilitate the |
| * calculation, the first argument contains the height of the Panel in the expanded state. |
| * |
| * @return The desired offset for the Base Page |
| */ |
| protected float calculateBasePageDesiredOffset() { |
| return 0.f; |
| } |
| |
| /** |
| * Updates the target offset of the Base Page in order to keep the selection in view |
| * after expanding the Panel. |
| */ |
| protected void updateBasePageTargetY() { |
| mBasePageTargetY = calculateBasePageTargetY(); |
| } |
| |
| /** |
| * Calculates the target offset of the Base Page in order to achieve the desired offset |
| * specified by {@link #calculateBasePageDesiredOffset} while assuring that the Base |
| * Page will always fill the gap between the Panel and the top of the screen, because |
| * there's nothing to see below the Base Page layer. This method will take into |
| * consideration the Toolbar height, and adjust the offset accordingly, in order to |
| * move the Toolbar out of the view as the Panel expands. |
| * |
| * @return The target offset Y. |
| */ |
| private float calculateBasePageTargetY() { |
| // Only a fullscreen wide Panel should offset the base page. A small panel should |
| // always return zero to ensure the Base Page remains in the same position. |
| if (!isFullWidthSizePanel()) return 0.f; |
| |
| // Start with the desired offset taking viewport offset into consideration and make sure |
| // the result is <= 0 so the page moves up and not down. |
| float offset = Math.min(calculateBasePageDesiredOffset() - mLayoutYOffset, 0.0f); |
| |
| // Make sure the offset is not greater than the expanded height, because |
| // there's nothing to render below the Page. |
| offset = Math.max(offset, -getExpandedHeight()); |
| |
| return offset; |
| } |
| |
| /** |
| * @return The Y coordinate to apply to the Base Page in order to keep the selection |
| * in view when the Overlay Panel is in EXPANDED state. |
| */ |
| private float getBasePageTargetY() { |
| return mBasePageTargetY; |
| } |
| |
| // ============================================================================================ |
| // Resource Loader |
| // ============================================================================================ |
| |
| protected ViewGroup mContainerView; |
| protected DynamicResourceLoader mResourceLoader; |
| |
| /** |
| * @param resourceLoader The {@link DynamicResourceLoader} to register and unregister the view. |
| */ |
| public void setDynamicResourceLoader(DynamicResourceLoader resourceLoader) { |
| mResourceLoader = resourceLoader; |
| } |
| |
| /** |
| * Sets the container ViewGroup to which the auxiliary Views will be attached to. |
| * |
| * @param container The {@link ViewGroup} container. |
| */ |
| public void setContainerView(ViewGroup container) { |
| mContainerView = container; |
| } |
| |
| // ============================================================================================ |
| // Test Infrastructure |
| // ============================================================================================ |
| |
| /** |
| * @param height The height of the Overlay Panel to be set. |
| */ |
| @VisibleForTesting |
| public void setHeightForTesting(float height) { |
| mHeight = height; |
| } |
| |
| /** |
| * @param offsetY The vertical offset of the Overlay Panel to be |
| * set. |
| */ |
| @VisibleForTesting |
| public void setOffsetYForTesting(float offsetY) { |
| mOffsetY = offsetY; |
| } |
| |
| /** |
| * @param isMaximized The setting for whether the Overlay Panel is fully |
| * maximized. |
| */ |
| @VisibleForTesting |
| public void setMaximizedForTesting(boolean isMaximized) { |
| mIsMaximized = isMaximized; |
| } |
| |
| /** |
| * @param barHeight The height of the Overlay Bar to be set. |
| */ |
| @VisibleForTesting |
| public void setSearchBarHeightForTesting(float barHeight) { |
| mBarHeight = barHeight; |
| } |
| |
| /** |
| * Overrides the FullWidthSizePanel state for testing. |
| * |
| * @param isFullWidthSizePanel Whether the Panel has a full width size. |
| */ |
| @VisibleForTesting |
| public void setIsFullWidthSizePanelForTesting(boolean isFullWidthSizePanel) { |
| mOverrideIsFullWidthSizePanelForTesting = true; |
| mIsFullWidthSizePanelForTesting = isFullWidthSizePanel; |
| } |
| } |
