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