Java tutorial
/* * 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.printspooler.widget; import android.content.Context; import android.support.v4.widget.ViewDragHelper; import android.util.AttributeSet; import android.view.MotionEvent; import android.view.View; import android.view.ViewGroup; import android.view.inputmethod.InputMethodManager; import com.android.printspooler.R; /** * This class is a layout manager for the print screen. It has a sliding * area that contains the print options. If the sliding area is open the * print options are visible and if it is closed a summary of the print * job is shown. Under the sliding area there is a place for putting * arbitrary content such as preview, error message, progress indicator, * etc. The sliding area is covering the content holder under it when * the former is opened. */ @SuppressWarnings("unused") public final class PrintContentView extends ViewGroup implements View.OnClickListener { private static final int FIRST_POINTER_ID = 0; private static final int ALPHA_MASK = 0xff000000; private static final int ALPHA_SHIFT = 24; private static final int COLOR_MASK = 0xffffff; private final ViewDragHelper mDragger; private final int mScrimColor; private View mStaticContent; private ViewGroup mSummaryContent; private View mDynamicContent; private View mDraggableContent; private View mPrintButton; private View mMoreOptionsButton; private ViewGroup mOptionsContainer; private View mEmbeddedContentContainer; private View mEmbeddedContentScrim; private View mExpandCollapseHandle; private View mExpandCollapseIcon; private int mClosedOptionsOffsetY; private int mCurrentOptionsOffsetY = Integer.MIN_VALUE; private OptionsStateChangeListener mOptionsStateChangeListener; private OptionsStateController mOptionsStateController; private int mOldDraggableHeight; private float mDragProgress; public interface OptionsStateChangeListener { public void onOptionsOpened(); public void onOptionsClosed(); } public interface OptionsStateController { public boolean canOpenOptions(); public boolean canCloseOptions(); } public PrintContentView(Context context, AttributeSet attrs) { super(context, attrs); mDragger = ViewDragHelper.create(this, new DragCallbacks()); mScrimColor = context.getResources().getColor(R.color.print_preview_scrim_color); // The options view is sliding under the static header but appears // after it in the layout, so we will draw in opposite order. setChildrenDrawingOrderEnabled(true); } public void setOptionsStateChangeListener(OptionsStateChangeListener listener) { mOptionsStateChangeListener = listener; } public void setOpenOptionsController(OptionsStateController controller) { mOptionsStateController = controller; } public boolean isOptionsOpened() { return mCurrentOptionsOffsetY == 0; } private boolean isOptionsClosed() { return mCurrentOptionsOffsetY == mClosedOptionsOffsetY; } public void openOptions() { if (isOptionsOpened()) { return; } mDragger.smoothSlideViewTo(mDynamicContent, mDynamicContent.getLeft(), getOpenedOptionsY()); invalidate(); } public void closeOptions() { if (isOptionsClosed()) { return; } mDragger.smoothSlideViewTo(mDynamicContent, mDynamicContent.getLeft(), getClosedOptionsY()); invalidate(); } @Override protected int getChildDrawingOrder(int childCount, int i) { return childCount - i - 1; } @Override protected void onFinishInflate() { mStaticContent = findViewById(R.id.static_content); mSummaryContent = (ViewGroup) findViewById(R.id.summary_content); mDynamicContent = findViewById(R.id.dynamic_content); mDraggableContent = findViewById(R.id.draggable_content); mPrintButton = findViewById(R.id.print_button); mMoreOptionsButton = findViewById(R.id.more_options_button); mOptionsContainer = (ViewGroup) findViewById(R.id.options_container); mEmbeddedContentContainer = findViewById(R.id.embedded_content_container); mEmbeddedContentScrim = findViewById(R.id.embedded_content_scrim); mExpandCollapseHandle = findViewById(R.id.expand_collapse_handle); mExpandCollapseIcon = findViewById(R.id.expand_collapse_icon); mExpandCollapseHandle.setOnClickListener(this); mSummaryContent.setOnClickListener(this); // Make sure we start in a closed options state. onDragProgress(1.0f); // The framework gives focus to the frist focusable and we // do not want that, hence we will take focus instead. setFocusableInTouchMode(true); } @Override public void focusableViewAvailable(View v) { // The framework gives focus to the frist focusable and we // do not want that, hence do not announce new focusables. return; } @Override public void onClick(View view) { if (view == mExpandCollapseHandle || view == mSummaryContent) { if (isOptionsClosed() && mOptionsStateController.canOpenOptions()) { openOptions(); } else if (isOptionsOpened() && mOptionsStateController.canCloseOptions()) { closeOptions(); } // else in open/close progress do nothing. } else if (view == mEmbeddedContentScrim) { if (isOptionsOpened() && mOptionsStateController.canCloseOptions()) { closeOptions(); } } } @Override public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) { /* do nothing */ } @Override public boolean onTouchEvent(MotionEvent event) { mDragger.processTouchEvent(event); return true; } @Override public boolean onInterceptTouchEvent(MotionEvent event) { return mDragger.shouldInterceptTouchEvent(event) || super.onInterceptTouchEvent(event); } @Override public void computeScroll() { if (mDragger.continueSettling(true)) { postInvalidateOnAnimation(); } } private int computeScrimColor() { final int baseAlpha = (mScrimColor & ALPHA_MASK) >>> ALPHA_SHIFT; final int adjustedAlpha = (int) (baseAlpha * (1 - mDragProgress)); return adjustedAlpha << ALPHA_SHIFT | (mScrimColor & COLOR_MASK); } private int getOpenedOptionsY() { return mStaticContent.getBottom(); } private int getClosedOptionsY() { return getOpenedOptionsY() + mClosedOptionsOffsetY; } @Override protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { final boolean wasOpened = isOptionsOpened(); measureChild(mStaticContent, widthMeasureSpec, heightMeasureSpec); if (mSummaryContent.getVisibility() != View.GONE) { measureChild(mSummaryContent, widthMeasureSpec, heightMeasureSpec); } measureChild(mDynamicContent, widthMeasureSpec, heightMeasureSpec); measureChild(mPrintButton, widthMeasureSpec, heightMeasureSpec); // The height of the draggable content may change and if that happens // we have to adjust the sliding area closed state offset. mClosedOptionsOffsetY = mSummaryContent.getMeasuredHeight() - mDraggableContent.getMeasuredHeight(); if (mCurrentOptionsOffsetY == Integer.MIN_VALUE) { mCurrentOptionsOffsetY = mClosedOptionsOffsetY; } final int heightSize = MeasureSpec.getSize(heightMeasureSpec); // The content host must be maximally large size that fits entirely // on the screen when the options are collapsed. ViewGroup.LayoutParams params = mEmbeddedContentContainer.getLayoutParams(); params.height = heightSize - mStaticContent.getMeasuredHeight() - mSummaryContent.getMeasuredHeight() - mDynamicContent.getMeasuredHeight() + mDraggableContent.getMeasuredHeight(); // The height of the draggable content may change and if that happens // we have to adjust the current offset to ensure the sliding area is // at the correct position. if (mOldDraggableHeight != mDraggableContent.getMeasuredHeight()) { if (mOldDraggableHeight != 0) { mCurrentOptionsOffsetY = wasOpened ? 0 : mClosedOptionsOffsetY; } mOldDraggableHeight = mDraggableContent.getMeasuredHeight(); } // The content host can grow vertically as much as needed - we will be covering it. final int hostHeightMeasureSpec = MeasureSpec.makeMeasureSpec(MeasureSpec.UNSPECIFIED, 0); measureChild(mEmbeddedContentContainer, widthMeasureSpec, hostHeightMeasureSpec); setMeasuredDimension(resolveSize(MeasureSpec.getSize(widthMeasureSpec), widthMeasureSpec), resolveSize(heightSize, heightMeasureSpec)); } @Override protected void onLayout(boolean changed, int left, int top, int right, int bottom) { mStaticContent.layout(left, top, right, mStaticContent.getMeasuredHeight()); if (mSummaryContent.getVisibility() != View.GONE) { mSummaryContent.layout(left, mStaticContent.getMeasuredHeight(), right, mStaticContent.getMeasuredHeight() + mSummaryContent.getMeasuredHeight()); } final int dynContentTop = mStaticContent.getMeasuredHeight() + mCurrentOptionsOffsetY; final int dynContentBottom = dynContentTop + mDynamicContent.getMeasuredHeight(); mDynamicContent.layout(left, dynContentTop, right, dynContentBottom); MarginLayoutParams params = (MarginLayoutParams) mPrintButton.getLayoutParams(); final int printButtonLeft; if (getLayoutDirection() == View.LAYOUT_DIRECTION_LTR) { printButtonLeft = right - mPrintButton.getMeasuredWidth() - params.getMarginStart(); } else { printButtonLeft = left + params.getMarginStart(); } final int printButtonTop = dynContentBottom - mPrintButton.getMeasuredHeight() / 2; final int printButtonRight = printButtonLeft + mPrintButton.getMeasuredWidth(); final int printButtonBottom = printButtonTop + mPrintButton.getMeasuredHeight(); mPrintButton.layout(printButtonLeft, printButtonTop, printButtonRight, printButtonBottom); final int embContentTop = mStaticContent.getMeasuredHeight() + mClosedOptionsOffsetY + mDynamicContent.getMeasuredHeight(); final int embContentBottom = embContentTop + mEmbeddedContentContainer.getMeasuredHeight(); mEmbeddedContentContainer.layout(left, embContentTop, right, embContentBottom); } @Override public LayoutParams generateLayoutParams(AttributeSet attrs) { return new ViewGroup.MarginLayoutParams(getContext(), attrs); } private void onDragProgress(float progress) { if (Float.compare(mDragProgress, progress) == 0) { return; } if ((mDragProgress == 0 && progress > 0) || (mDragProgress == 1.0f && progress < 1.0f)) { mSummaryContent.setLayerType(View.LAYER_TYPE_HARDWARE, null); mDraggableContent.setLayerType(View.LAYER_TYPE_HARDWARE, null); mMoreOptionsButton.setLayerType(View.LAYER_TYPE_HARDWARE, null); ensureImeClosedAndInputFocusCleared(); } if ((mDragProgress > 0 && progress == 0) || (mDragProgress < 1.0f && progress == 1.0f)) { mSummaryContent.setLayerType(View.LAYER_TYPE_NONE, null); mDraggableContent.setLayerType(View.LAYER_TYPE_NONE, null); mMoreOptionsButton.setLayerType(View.LAYER_TYPE_NONE, null); mMoreOptionsButton.setLayerType(View.LAYER_TYPE_NONE, null); } mDragProgress = progress; mSummaryContent.setAlpha(progress); final float inverseAlpha = 1.0f - progress; mOptionsContainer.setAlpha(inverseAlpha); mMoreOptionsButton.setAlpha(inverseAlpha); mEmbeddedContentScrim.setBackgroundColor(computeScrimColor()); if (progress == 0) { if (mOptionsStateChangeListener != null) { mOptionsStateChangeListener.onOptionsOpened(); } mExpandCollapseHandle.setContentDescription(mContext.getString(R.string.collapse_handle)); announceForAccessibility(mContext.getString(R.string.print_options_expanded)); mSummaryContent.setVisibility(View.GONE); mEmbeddedContentScrim.setOnClickListener(this); mExpandCollapseIcon.setBackgroundResource(R.drawable.ic_expand_less); } else { mSummaryContent.setVisibility(View.VISIBLE); } if (progress == 1.0f) { if (mOptionsStateChangeListener != null) { mOptionsStateChangeListener.onOptionsClosed(); } mExpandCollapseHandle.setContentDescription(mContext.getString(R.string.expand_handle)); announceForAccessibility(mContext.getString(R.string.print_options_collapsed)); if (mMoreOptionsButton.getVisibility() != View.GONE) { mMoreOptionsButton.setVisibility(View.INVISIBLE); } mDraggableContent.setVisibility(View.INVISIBLE); // If we change the scrim visibility the dimming is lagging // and is janky. Now it is there but transparent, doing nothing. mEmbeddedContentScrim.setOnClickListener(null); mEmbeddedContentScrim.setClickable(false); mExpandCollapseIcon.setBackgroundResource(R.drawable.ic_expand_more); } else { if (mMoreOptionsButton.getVisibility() != View.GONE) { mMoreOptionsButton.setVisibility(View.VISIBLE); } mDraggableContent.setVisibility(View.VISIBLE); } } private void ensureImeClosedAndInputFocusCleared() { View focused = findFocus(); if (focused != null && focused.isFocused()) { InputMethodManager imm = (InputMethodManager) mContext.getSystemService(Context.INPUT_METHOD_SERVICE); if (imm.isActive(focused)) { imm.hideSoftInputFromWindow(getWindowToken(), 0); } focused.clearFocus(); } } private final class DragCallbacks extends ViewDragHelper.Callback { @Override public boolean tryCaptureView(View child, int pointerId) { if (isOptionsOpened() && !mOptionsStateController.canCloseOptions() || isOptionsClosed() && !mOptionsStateController.canOpenOptions()) { return false; } return child == mDynamicContent && pointerId == FIRST_POINTER_ID; } @Override public void onViewPositionChanged(View changedView, int left, int top, int dx, int dy) { if ((isOptionsClosed() || isOptionsClosed()) && dy <= 0) { return; } mCurrentOptionsOffsetY += dy; final float progress = ((float) top - getOpenedOptionsY()) / (getClosedOptionsY() - getOpenedOptionsY()); mPrintButton.offsetTopAndBottom(dy); mDraggableContent.notifySubtreeAccessibilityStateChangedIfNeeded(); onDragProgress(progress); } public void onViewReleased(View child, float velocityX, float velocityY) { final int childTop = child.getTop(); final int openedOptionsY = getOpenedOptionsY(); final int closedOptionsY = getClosedOptionsY(); if (childTop == openedOptionsY || childTop == closedOptionsY) { return; } final int halfRange = closedOptionsY + (openedOptionsY - closedOptionsY) / 2; if (childTop < halfRange) { mDragger.smoothSlideViewTo(child, child.getLeft(), closedOptionsY); } else { mDragger.smoothSlideViewTo(child, child.getLeft(), openedOptionsY); } invalidate(); } public int getOrderedChildIndex(int index) { return getChildCount() - index - 1; } public int getViewVerticalDragRange(View child) { return mDraggableContent.getHeight(); } public int clampViewPositionVertical(View child, int top, int dy) { final int staticOptionBottom = mStaticContent.getBottom(); return Math.max(Math.min(top, getOpenedOptionsY()), getClosedOptionsY()); } } }