Home | History | Annotate | Download | only in launcher2 
      1 /*
      2  * Copyright (C) 2008 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.launcher2;
     18 
     19 import android.content.Context;
     20 import android.content.res.Resources;
     21 import android.graphics.Bitmap;
     22 import android.graphics.Canvas;
     23 import android.graphics.Rect;
     24 import android.graphics.Region;
     25 import android.graphics.Region.Op;
     26 import android.graphics.drawable.Drawable;
     27 import android.util.AttributeSet;
     28 import android.view.MotionEvent;
     29 import android.widget.TextView;
     30 
     31 /**
     32  * TextView that draws a bubble behind the text. We cannot use a LineBackgroundSpan
     33  * because we want to make the bubble taller than the text and TextView's clip is
     34  * too aggressive.
     35  */
     36 public class BubbleTextView extends TextView {
     37     static final float CORNER_RADIUS = 4.0f;
     38     static final float SHADOW_LARGE_RADIUS = 4.0f;
     39     static final float SHADOW_SMALL_RADIUS = 1.75f;
     40     static final float SHADOW_Y_OFFSET = 2.0f;
     41     static final int SHADOW_LARGE_COLOUR = 0xDD000000;
     42     static final int SHADOW_SMALL_COLOUR = 0xCC000000;
     43     static final float PADDING_H = 8.0f;
     44     static final float PADDING_V = 3.0f;
     45 
     46     private int mPrevAlpha = -1;
     47 
     48     private final HolographicOutlineHelper mOutlineHelper = new HolographicOutlineHelper();
     49     private final Canvas mTempCanvas = new Canvas();
     50     private final Rect mTempRect = new Rect();
     51     private boolean mDidInvalidateForPressedState;
     52     private Bitmap mPressedOrFocusedBackground;
     53     private int mFocusedOutlineColor;
     54     private int mFocusedGlowColor;
     55     private int mPressedOutlineColor;
     56     private int mPressedGlowColor;
     57 
     58     private boolean mBackgroundSizeChanged;
     59     private Drawable mBackground;
     60 
     61     private boolean mStayPressed;
     62     private CheckLongPressHelper mLongPressHelper;
     63 
     64     public BubbleTextView(Context context) {
     65         super(context);
     66         init();
     67     }
     68 
     69     public BubbleTextView(Context context, AttributeSet attrs) {
     70         super(context, attrs);
     71         init();
     72     }
     73 
     74     public BubbleTextView(Context context, AttributeSet attrs, int defStyle) {
     75         super(context, attrs, defStyle);
     76         init();
     77     }
     78 
     79     private void init() {
     80         mLongPressHelper = new CheckLongPressHelper(this);
     81         mBackground = getBackground();
     82 
     83         final Resources res = getContext().getResources();
     84         mFocusedOutlineColor = mFocusedGlowColor = mPressedOutlineColor = mPressedGlowColor =
     85             res.getColor(android.R.color.holo_blue_light);
     86 
     87         setShadowLayer(SHADOW_LARGE_RADIUS, 0.0f, SHADOW_Y_OFFSET, SHADOW_LARGE_COLOUR);
     88     }
     89 
     90     public void applyFromShortcutInfo(ShortcutInfo info, IconCache iconCache) {
     91         Bitmap b = info.getIcon(iconCache);
     92 
     93         setCompoundDrawablesWithIntrinsicBounds(null,
     94                 new FastBitmapDrawable(b),
     95                 null, null);
     96         setText(info.title);
     97         setTag(info);
     98     }
     99 
    100     @Override
    101     protected boolean setFrame(int left, int top, int right, int bottom) {
    102         if (getLeft() != left || getRight() != right || getTop() != top || getBottom() != bottom) {
    103             mBackgroundSizeChanged = true;
    104         }
    105         return super.setFrame(left, top, right, bottom);
    106     }
    107 
    108     @Override
    109     protected boolean verifyDrawable(Drawable who) {
    110         return who == mBackground || super.verifyDrawable(who);
    111     }
    112 
    113     @Override
    114     protected void drawableStateChanged() {
    115         if (isPressed()) {
    116             // In this case, we have already created the pressed outline on ACTION_DOWN,
    117             // so we just need to do an invalidate to trigger draw
    118             if (!mDidInvalidateForPressedState) {
    119                 setCellLayoutPressedOrFocusedIcon();
    120             }
    121         } else {
    122             // Otherwise, either clear the pressed/focused background, or create a background
    123             // for the focused state
    124             final boolean backgroundEmptyBefore = mPressedOrFocusedBackground == null;
    125             if (!mStayPressed) {
    126                 mPressedOrFocusedBackground = null;
    127             }
    128             if (isFocused()) {
    129                 if (getLayout() == null) {
    130                     // In some cases, we get focus before we have been layed out. Set the
    131                     // background to null so that it will get created when the view is drawn.
    132                     mPressedOrFocusedBackground = null;
    133                 } else {
    134                     mPressedOrFocusedBackground = createGlowingOutline(
    135                             mTempCanvas, mFocusedGlowColor, mFocusedOutlineColor);
    136                 }
    137                 mStayPressed = false;
    138                 setCellLayoutPressedOrFocusedIcon();
    139             }
    140             final boolean backgroundEmptyNow = mPressedOrFocusedBackground == null;
    141             if (!backgroundEmptyBefore && backgroundEmptyNow) {
    142                 setCellLayoutPressedOrFocusedIcon();
    143             }
    144         }
    145 
    146         Drawable d = mBackground;
    147         if (d != null && d.isStateful()) {
    148             d.setState(getDrawableState());
    149         }
    150         super.drawableStateChanged();
    151     }
    152 
    153     /**
    154      * Draw this BubbleTextView into the given Canvas.
    155      *
    156      * @param destCanvas the canvas to draw on
    157      * @param padding the horizontal and vertical padding to use when drawing
    158      */
    159     private void drawWithPadding(Canvas destCanvas, int padding) {
    160         final Rect clipRect = mTempRect;
    161         getDrawingRect(clipRect);
    162 
    163         // adjust the clip rect so that we don't include the text label
    164         clipRect.bottom =
    165             getExtendedPaddingTop() - (int) BubbleTextView.PADDING_V + getLayout().getLineTop(0);
    166 
    167         // Draw the View into the bitmap.
    168         // The translate of scrollX and scrollY is necessary when drawing TextViews, because
    169         // they set scrollX and scrollY to large values to achieve centered text
    170         destCanvas.save();
    171         destCanvas.scale(getScaleX(), getScaleY(),
    172                 (getWidth() + padding) / 2, (getHeight() + padding) / 2);
    173         destCanvas.translate(-getScrollX() + padding / 2, -getScrollY() + padding / 2);
    174         destCanvas.clipRect(clipRect, Op.REPLACE);
    175         draw(destCanvas);
    176         destCanvas.restore();
    177     }
    178 
    179     /**
    180      * Returns a new bitmap to be used as the object outline, e.g. to visualize the drop location.
    181      * Responsibility for the bitmap is transferred to the caller.
    182      */
    183     private Bitmap createGlowingOutline(Canvas canvas, int outlineColor, int glowColor) {
    184         final int padding = HolographicOutlineHelper.MAX_OUTER_BLUR_RADIUS;
    185         final Bitmap b = Bitmap.createBitmap(
    186                 getWidth() + padding, getHeight() + padding, Bitmap.Config.ARGB_8888);
    187 
    188         canvas.setBitmap(b);
    189         drawWithPadding(canvas, padding);
    190         mOutlineHelper.applyExtraThickExpensiveOutlineWithBlur(b, canvas, glowColor, outlineColor);
    191         canvas.setBitmap(null);
    192 
    193         return b;
    194     }
    195 
    196     @Override
    197     public boolean onTouchEvent(MotionEvent event) {
    198         // Call the superclass onTouchEvent first, because sometimes it changes the state to
    199         // isPressed() on an ACTION_UP
    200         boolean result = super.onTouchEvent(event);
    201 
    202         switch (event.getAction()) {
    203             case MotionEvent.ACTION_DOWN:
    204                 // So that the pressed outline is visible immediately when isPressed() is true,
    205                 // we pre-create it on ACTION_DOWN (it takes a small but perceptible amount of time
    206                 // to create it)
    207                 if (mPressedOrFocusedBackground == null) {
    208                     mPressedOrFocusedBackground = createGlowingOutline(
    209                             mTempCanvas, mPressedGlowColor, mPressedOutlineColor);
    210                 }
    211                 // Invalidate so the pressed state is visible, or set a flag so we know that we
    212                 // have to call invalidate as soon as the state is "pressed"
    213                 if (isPressed()) {
    214                     mDidInvalidateForPressedState = true;
    215                     setCellLayoutPressedOrFocusedIcon();
    216                 } else {
    217                     mDidInvalidateForPressedState = false;
    218                 }
    219 
    220                 mLongPressHelper.postCheckForLongPress();
    221                 break;
    222             case MotionEvent.ACTION_CANCEL:
    223             case MotionEvent.ACTION_UP:
    224                 // If we've touched down and up on an item, and it's still not "pressed", then
    225                 // destroy the pressed outline
    226                 if (!isPressed()) {
    227                     mPressedOrFocusedBackground = null;
    228                 }
    229 
    230                 mLongPressHelper.cancelLongPress();
    231                 break;
    232         }
    233         return result;
    234     }
    235 
    236     void setStayPressed(boolean stayPressed) {
    237         mStayPressed = stayPressed;
    238         if (!stayPressed) {
    239             mPressedOrFocusedBackground = null;
    240         }
    241         setCellLayoutPressedOrFocusedIcon();
    242     }
    243 
    244     void setCellLayoutPressedOrFocusedIcon() {
    245         if (getParent() instanceof ShortcutAndWidgetContainer) {
    246             ShortcutAndWidgetContainer parent = (ShortcutAndWidgetContainer) getParent();
    247             if (parent != null) {
    248                 CellLayout layout = (CellLayout) parent.getParent();
    249                 layout.setPressedOrFocusedIcon((mPressedOrFocusedBackground != null) ? this : null);
    250             }
    251         }
    252     }
    253 
    254     void clearPressedOrFocusedBackground() {
    255         mPressedOrFocusedBackground = null;
    256         setCellLayoutPressedOrFocusedIcon();
    257     }
    258 
    259     Bitmap getPressedOrFocusedBackground() {
    260         return mPressedOrFocusedBackground;
    261     }
    262 
    263     int getPressedOrFocusedBackgroundPadding() {
    264         return HolographicOutlineHelper.MAX_OUTER_BLUR_RADIUS / 2;
    265     }
    266 
    267     @Override
    268     public void draw(Canvas canvas) {
    269         final Drawable background = mBackground;
    270         if (background != null) {
    271             final int scrollX = getScrollX();
    272             final int scrollY = getScrollY();
    273 
    274             if (mBackgroundSizeChanged) {
    275                 background.setBounds(0, 0,  getRight() - getLeft(), getBottom() - getTop());
    276                 mBackgroundSizeChanged = false;
    277             }
    278 
    279             if ((scrollX | scrollY) == 0) {
    280                 background.draw(canvas);
    281             } else {
    282                 canvas.translate(scrollX, scrollY);
    283                 background.draw(canvas);
    284                 canvas.translate(-scrollX, -scrollY);
    285             }
    286         }
    287 
    288         // If text is transparent, don't draw any shadow
    289         if (getCurrentTextColor() == getResources().getColor(android.R.color.transparent)) {
    290             getPaint().clearShadowLayer();
    291             super.draw(canvas);
    292             return;
    293         }
    294 
    295         // We enhance the shadow by drawing the shadow twice
    296         getPaint().setShadowLayer(SHADOW_LARGE_RADIUS, 0.0f, SHADOW_Y_OFFSET, SHADOW_LARGE_COLOUR);
    297         super.draw(canvas);
    298         canvas.save(Canvas.CLIP_SAVE_FLAG);
    299         canvas.clipRect(getScrollX(), getScrollY() + getExtendedPaddingTop(),
    300                 getScrollX() + getWidth(),
    301                 getScrollY() + getHeight(), Region.Op.INTERSECT);
    302         getPaint().setShadowLayer(SHADOW_SMALL_RADIUS, 0.0f, 0.0f, SHADOW_SMALL_COLOUR);
    303         super.draw(canvas);
    304         canvas.restore();
    305     }
    306 
    307     @Override
    308     protected void onAttachedToWindow() {
    309         super.onAttachedToWindow();
    310         if (mBackground != null) mBackground.setCallback(this);
    311     }
    312 
    313     @Override
    314     protected void onDetachedFromWindow() {
    315         super.onDetachedFromWindow();
    316         if (mBackground != null) mBackground.setCallback(null);
    317     }
    318 
    319     @Override
    320     protected boolean onSetAlpha(int alpha) {
    321         if (mPrevAlpha != alpha) {
    322             mPrevAlpha = alpha;
    323             super.onSetAlpha(alpha);
    324         }
    325         return true;
    326     }
    327 
    328     @Override
    329     public void cancelLongPress() {
    330         super.cancelLongPress();
    331 
    332         mLongPressHelper.cancelLongPress();
    333     }
    334 }
    335