packages/PrintSpooler/src/com/android/printspooler/widget/PrintContentView.java

   1 /*
   2  * Copyright (C) 2014 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.printspooler.widget;
  18
  19 import android.content.Context;
  20 import android.support.v4.widget.ViewDragHelper;
  21 import android.util.AttributeSet;
  22 import android.view.MotionEvent;
  23 import android.view.View;
  24 import android.view.ViewGroup;
  25 import android.view.inputmethod.InputMethodManager;
  26 import com.android.printspooler.R;
  27
  28 /**
  29  * This class is a layout manager for the print screen. It has a sliding
  30  * area that contains the print options. If the sliding area is open the
  31  * print options are visible and if it is closed a summary of the print
  32  * job is shown. Under the sliding area there is a place for putting
  33  * arbitrary content such as preview, error message, progress indicator,
  34  * etc. The sliding area is covering the content holder under it when
  35  * the former is opened.
  36  */
  37 @SuppressWarnings("unused")
  38 public final class PrintContentView extends ViewGroup implements View.OnClickListener {
  39     private static final int FIRST_POINTER_ID = 0;
  40
  41     private static final int ALPHA_MASK = 0xff000000;
  42     private static final int ALPHA_SHIFT = 24;
  43
  44     private static final int COLOR_MASK = 0xffffff;
  45
  46     private final ViewDragHelper mDragger;
  47
  48     private final int mScrimColor;
  49
  50     private View mStaticContent;
  51     private ViewGroup mSummaryContent;
  52     private View mDynamicContent;
  53
  54     private View mDraggableContent;
  55     private View mPrintButton;
  56     private View mMoreOptionsButton;
  57     private ViewGroup mOptionsContainer;
  58
  59     private View mEmbeddedContentContainer;
  60     private View mEmbeddedContentScrim;
  61
  62     private View mExpandCollapseHandle;
  63     private View mExpandCollapseIcon;
  64
  65     private int mClosedOptionsOffsetY;
  66     private int mCurrentOptionsOffsetY = Integer.MIN_VALUE;
  67
  68     private OptionsStateChangeListener mOptionsStateChangeListener;
  69
  70     private OptionsStateController mOptionsStateController;
  71
  72     private int mOldDraggableHeight;
  73
  74     private float mDragProgress;
  75
  76     public interface OptionsStateChangeListener {
  77         public void onOptionsOpened();
  78         public void onOptionsClosed();
  79     }
  80
  81     public interface OptionsStateController {
  82         public boolean canOpenOptions();
  83         public boolean canCloseOptions();
  84     }
  85
  86     public PrintContentView(Context context, AttributeSet attrs) {
  87         super(context, attrs);
  88         mDragger = ViewDragHelper.create(this, new DragCallbacks());
  89
  90         mScrimColor = context.getColor(R.color.print_preview_scrim_color);
  91
  92         // The options view is sliding under the static header but appears
  93         // after it in the layout, so we will draw in opposite order.
  94         setChildrenDrawingOrderEnabled(true);
  95     }
  96
  97     public void setOptionsStateChangeListener(OptionsStateChangeListener listener) {
  98         mOptionsStateChangeListener = listener;
  99     }
 100
 101     public void setOpenOptionsController(OptionsStateController controller) {
 102         mOptionsStateController = controller;
 103     }
 104
 105     public boolean isOptionsOpened() {
 106         return mCurrentOptionsOffsetY == 0;
 107     }
 108
 109     private boolean isOptionsClosed() {
 110         return mCurrentOptionsOffsetY == mClosedOptionsOffsetY;
 111     }
 112
 113     public void openOptions() {
 114         if (isOptionsOpened()) {
 115             return;
 116         }
 117         mDragger.smoothSlideViewTo(mDynamicContent, mDynamicContent.getLeft(),
 118                 getOpenedOptionsY());
 119         invalidate();
 120     }
 121
 122     public void closeOptions() {
 123         if (isOptionsClosed()) {
 124             return;
 125         }
 126         mDragger.smoothSlideViewTo(mDynamicContent, mDynamicContent.getLeft(),
 127                 getClosedOptionsY());
 128         invalidate();
 129     }
 130
 131     @Override
 132     protected int getChildDrawingOrder(int childCount, int i) {
 133         return childCount - i - 1;
 134     }
 135
 136     @Override
 137     protected void onFinishInflate() {
 138         mStaticContent = findViewById(R.id.static_content);
 139         mSummaryContent = findViewById(R.id.summary_content);
 140         mDynamicContent = findViewById(R.id.dynamic_content);
 141         mDraggableContent = findViewById(R.id.draggable_content);
 142         mPrintButton = findViewById(R.id.print_button);
 143         mMoreOptionsButton = findViewById(R.id.more_options_button);
 144         mOptionsContainer = findViewById(R.id.options_container);
 145         mEmbeddedContentContainer = findViewById(R.id.embedded_content_container);
 146         mEmbeddedContentScrim = findViewById(R.id.embedded_content_scrim);
 147         mExpandCollapseHandle = findViewById(R.id.expand_collapse_handle);
 148         mExpandCollapseIcon = findViewById(R.id.expand_collapse_icon);
 149
 150         mExpandCollapseHandle.setOnClickListener(this);
 151         mSummaryContent.setOnClickListener(this);
 152
 153         // Make sure we start in a closed options state.
 154         onDragProgress(1.0f);
 155
 156         // The framework gives focus to the frist focusable and we
 157         // do not want that, hence we will take focus instead.
 158         setFocusableInTouchMode(true);
 159     }
 160
 161     @Override
 162     public void focusableViewAvailable(View v) {
 163         // The framework gives focus to the frist focusable and we
 164         // do not want that, hence do not announce new focusables.
 165         return;
 166     }
 167
 168     @Override
 169     public void onClick(View view) {
 170         if (view == mExpandCollapseHandle || view == mSummaryContent) {
 171             if (isOptionsClosed() && mOptionsStateController.canOpenOptions()) {
 172                 openOptions();
 173             } else if (isOptionsOpened() && mOptionsStateController.canCloseOptions()) {
 174                 closeOptions();
 175             } // else in open/close progress do nothing.
 176         } else if (view == mEmbeddedContentScrim) {
 177             if (isOptionsOpened() && mOptionsStateController.canCloseOptions()) {
 178                 closeOptions();
 179             }
 180         }
 181     }
 182
 183     @Override
 184     public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {
 185         /* do nothing */
 186     }
 187
 188     @Override
 189     public boolean onTouchEvent(MotionEvent event) {
 190         mDragger.processTouchEvent(event);
 191         return true;
 192     }
 193
 194     @Override
 195     public boolean onInterceptTouchEvent(MotionEvent event) {
 196         return mDragger.shouldInterceptTouchEvent(event)
 197                 || super.onInterceptTouchEvent(event);
 198     }
 199
 200     @Override
 201     public void computeScroll() {
 202         if (mDragger.continueSettling(true)) {
 203             postInvalidateOnAnimation();
 204         }
 205     }
 206
 207     private int computeScrimColor() {
 208         final int baseAlpha = (mScrimColor & ALPHA_MASK) >>> ALPHA_SHIFT;
 209         final int adjustedAlpha = (int) (baseAlpha * (1 - mDragProgress));
 210         return adjustedAlpha << ALPHA_SHIFT | (mScrimColor & COLOR_MASK);
 211     }
 212
 213     private int getOpenedOptionsY() {
 214         return mStaticContent.getBottom();
 215     }
 216
 217     private int getClosedOptionsY() {
 218         return getOpenedOptionsY() + mClosedOptionsOffsetY;
 219     }
 220
 221     @Override
 222     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
 223         final boolean wasOpened = isOptionsOpened();
 224
 225         measureChild(mStaticContent, widthMeasureSpec, heightMeasureSpec);
 226
 227         if (mSummaryContent.getVisibility() != View.GONE) {
 228             measureChild(mSummaryContent, widthMeasureSpec, heightMeasureSpec);
 229         }
 230
 231         measureChild(mDynamicContent, widthMeasureSpec, heightMeasureSpec);
 232
 233         measureChild(mPrintButton, widthMeasureSpec, heightMeasureSpec);
 234
 235         // The height of the draggable content may change and if that happens
 236         // we have to adjust the sliding area closed state offset.
 237         mClosedOptionsOffsetY = mSummaryContent.getMeasuredHeight()
 238                 - mDraggableContent.getMeasuredHeight();
 239
 240         if (mCurrentOptionsOffsetY == Integer.MIN_VALUE) {
 241             mCurrentOptionsOffsetY = mClosedOptionsOffsetY;
 242         }
 243
 244         final int heightSize = MeasureSpec.getSize(heightMeasureSpec);
 245
 246         // The content host must be maximally large size that fits entirely
 247         // on the screen when the options are collapsed.
 248         ViewGroup.LayoutParams params = mEmbeddedContentContainer.getLayoutParams();
 249         params.height = heightSize - mStaticContent.getMeasuredHeight()
 250                 - mSummaryContent.getMeasuredHeight() - mDynamicContent.getMeasuredHeight()
 251                 + mDraggableContent.getMeasuredHeight();
 252
 253         // The height of the draggable content may change and if that happens
 254         // we have to adjust the current offset to ensure the sliding area is
 255         // at the correct position.
 256         if (mOldDraggableHeight != mDraggableContent.getMeasuredHeight()) {
 257             if (mOldDraggableHeight != 0) {
 258                 mCurrentOptionsOffsetY = wasOpened ? 0 : mClosedOptionsOffsetY;
 259             }
 260             mOldDraggableHeight = mDraggableContent.getMeasuredHeight();
 261         }
 262
 263         // The content host can grow vertically as much as needed - we will be covering it.
 264         final int hostHeightMeasureSpec = MeasureSpec.makeMeasureSpec(MeasureSpec.UNSPECIFIED, 0);
 265         measureChild(mEmbeddedContentContainer, widthMeasureSpec, hostHeightMeasureSpec);
 266
 267         setMeasuredDimension(resolveSize(MeasureSpec.getSize(widthMeasureSpec), widthMeasureSpec),
 268                 resolveSize(heightSize, heightMeasureSpec));
 269     }
 270
 271     @Override
 272     protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
 273         mStaticContent.layout(left, top, right, mStaticContent.getMeasuredHeight());
 274
 275         if (mSummaryContent.getVisibility() != View.GONE) {
 276             mSummaryContent.layout(left, mStaticContent.getMeasuredHeight(), right,
 277                     mStaticContent.getMeasuredHeight() + mSummaryContent.getMeasuredHeight());
 278         }
 279
 280         final int dynContentTop = mStaticContent.getMeasuredHeight() + mCurrentOptionsOffsetY;
 281         final int dynContentBottom = dynContentTop + mDynamicContent.getMeasuredHeight();
 282
 283         mDynamicContent.layout(left, dynContentTop, right, dynContentBottom);
 284
 285         MarginLayoutParams params = (MarginLayoutParams) mPrintButton.getLayoutParams();
 286
 287         final int printButtonLeft;
 288         if (getLayoutDirection() == View.LAYOUT_DIRECTION_LTR) {
 289             printButtonLeft = right - mPrintButton.getMeasuredWidth() - params.getMarginStart();
 290         } else {
 291             printButtonLeft = left + params.getMarginStart();
 292         }
 293         final int printButtonTop = dynContentBottom - mPrintButton.getMeasuredHeight() / 2;
 294         final int printButtonRight = printButtonLeft + mPrintButton.getMeasuredWidth();
 295         final int printButtonBottom = printButtonTop + mPrintButton.getMeasuredHeight();
 296
 297         mPrintButton.layout(printButtonLeft, printButtonTop, printButtonRight, printButtonBottom);
 298
 299         final int embContentTop = mStaticContent.getMeasuredHeight() + mClosedOptionsOffsetY
 300                 + mDynamicContent.getMeasuredHeight();
 301         final int embContentBottom = embContentTop + mEmbeddedContentContainer.getMeasuredHeight();
 302
 303         mEmbeddedContentContainer.layout(left, embContentTop, right, embContentBottom);
 304     }
 305
 306     @Override
 307     public LayoutParams generateLayoutParams(AttributeSet attrs) {
 308         return new ViewGroup.MarginLayoutParams(getContext(), attrs);
 309     }
 310
 311     private void onDragProgress(float progress) {
 312         if (Float.compare(mDragProgress, progress) == 0) {
 313             return;
 314         }
 315
 316         if ((mDragProgress == 0 && progress > 0)
 317                 || (mDragProgress == 1.0f && progress < 1.0f)) {
 318             mSummaryContent.setLayerType(View.LAYER_TYPE_HARDWARE, null);
 319             mDraggableContent.setLayerType(View.LAYER_TYPE_HARDWARE, null);
 320             mMoreOptionsButton.setLayerType(View.LAYER_TYPE_HARDWARE, null);
 321             ensureImeClosedAndInputFocusCleared();
 322         }
 323         if ((mDragProgress > 0 && progress == 0)
 324                 || (mDragProgress < 1.0f && progress == 1.0f)) {
 325             mSummaryContent.setLayerType(View.LAYER_TYPE_NONE, null);
 326             mDraggableContent.setLayerType(View.LAYER_TYPE_NONE, null);
 327             mMoreOptionsButton.setLayerType(View.LAYER_TYPE_NONE, null);
 328             mMoreOptionsButton.setLayerType(View.LAYER_TYPE_NONE, null);
 329         }
 330
 331         mDragProgress = progress;
 332
 333         mSummaryContent.setAlpha(progress);
 334
 335         final float inverseAlpha = 1.0f - progress;
 336         mOptionsContainer.setAlpha(inverseAlpha);
 337         mMoreOptionsButton.setAlpha(inverseAlpha);
 338
 339         mEmbeddedContentScrim.setBackgroundColor(computeScrimColor());
 340         if (progress == 0) {
 341             if (mOptionsStateChangeListener != null) {
 342                 mOptionsStateChangeListener.onOptionsOpened();
 343             }
 344             mExpandCollapseHandle.setContentDescription(
 345                     mContext.getString(R.string.collapse_handle));
 346             announceForAccessibility(mContext.getString(R.string.print_options_expanded));
 347             mSummaryContent.setVisibility(View.GONE);
 348             mEmbeddedContentScrim.setOnClickListener(this);
 349             mExpandCollapseIcon.setBackgroundResource(R.drawable.ic_expand_less);
 350         } else {
 351             mSummaryContent.setVisibility(View.VISIBLE);
 352         }
 353
 354         if (progress == 1.0f) {
 355             if (mOptionsStateChangeListener != null) {
 356                 mOptionsStateChangeListener.onOptionsClosed();
 357             }
 358             mExpandCollapseHandle.setContentDescription(
 359                     mContext.getString(R.string.expand_handle));
 360             announceForAccessibility(mContext.getString(R.string.print_options_collapsed));
 361             if (mMoreOptionsButton.getVisibility() != View.GONE) {
 362                 mMoreOptionsButton.setVisibility(View.INVISIBLE);
 363             }
 364             mDraggableContent.setVisibility(View.INVISIBLE);
 365             // If we change the scrim visibility the dimming is lagging
 366             // and is janky. Now it is there but transparent, doing nothing.
 367             mEmbeddedContentScrim.setOnClickListener(null);
 368             mEmbeddedContentScrim.setClickable(false);
 369             mExpandCollapseIcon.setBackgroundResource(R.drawable.ic_expand_more);
 370         } else {
 371             if (mMoreOptionsButton.getVisibility() != View.GONE) {
 372                 mMoreOptionsButton.setVisibility(View.VISIBLE);
 373             }
 374             mDraggableContent.setVisibility(View.VISIBLE);
 375         }
 376     }
 377
 378     private void ensureImeClosedAndInputFocusCleared() {
 379         View focused = findFocus();
 380
 381         if (focused != null && focused.isFocused()) {
 382             InputMethodManager imm = (InputMethodManager) mContext.getSystemService(
 383                     Context.INPUT_METHOD_SERVICE);
 384             if (imm.isActive(focused)) {
 385                 imm.hideSoftInputFromWindow(getWindowToken(), 0);
 386             }
 387             focused.clearFocus();
 388         }
 389     }
 390
 391     private final class DragCallbacks extends ViewDragHelper.Callback {
 392         @Override
 393         public boolean tryCaptureView(View child, int pointerId) {
 394             if (isOptionsOpened() && !mOptionsStateController.canCloseOptions()
 395                     || isOptionsClosed() && !mOptionsStateController.canOpenOptions()) {
 396                 return false;
 397             }
 398             return child == mDynamicContent && pointerId == FIRST_POINTER_ID;
 399         }
 400
 401         @Override
 402         public void onViewPositionChanged(View changedView, int left, int top, int dx, int dy) {
 403             if ((isOptionsClosed() || isOptionsClosed()) && dy <= 0) {
 404                 return;
 405             }
 406
 407             mCurrentOptionsOffsetY += dy;
 408             final float progress = ((float) top - getOpenedOptionsY())
 409                     / (getClosedOptionsY() - getOpenedOptionsY());
 410
 411             mPrintButton.offsetTopAndBottom(dy);
 412
 413             mDraggableContent.notifySubtreeAccessibilityStateChangedIfNeeded();
 414
 415             onDragProgress(progress);
 416         }
 417
 418         @Override
 419         public void onViewReleased(View child, float velocityX, float velocityY) {
 420             final int childTop = child.getTop();
 421
 422             final int openedOptionsY = getOpenedOptionsY();
 423             final int closedOptionsY = getClosedOptionsY();
 424
 425             if (childTop == openedOptionsY || childTop == closedOptionsY) {
 426                 return;
 427             }
 428
 429             final int halfRange = closedOptionsY + (openedOptionsY - closedOptionsY) / 2;
 430             if (childTop < halfRange) {
 431                 mDragger.smoothSlideViewTo(child, child.getLeft(), closedOptionsY);
 432             } else {
 433                 mDragger.smoothSlideViewTo(child, child.getLeft(), openedOptionsY);
 434             }
 435
 436             invalidate();
 437         }
 438
 439         @Override
 440         public int getOrderedChildIndex(int index) {
 441             return getChildCount() - index - 1;
 442         }
 443
 444         @Override
 445         public int getViewVerticalDragRange(View child) {
 446             return mDraggableContent.getHeight();
 447         }
 448
 449         @Override
 450         public int clampViewPositionVertical(View child, int top, int dy) {
 451             final int staticOptionBottom = mStaticContent.getBottom();
 452             return Math.max(Math.min(top, getOpenedOptionsY()), getClosedOptionsY());
 453         }
 454     }
 455 }