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
17package com.android.launcher2;
18
19import android.content.Context;
20import android.content.res.Resources;
21import android.graphics.Bitmap;
22import android.graphics.Canvas;
23import android.graphics.Color;
24import android.graphics.Paint;
25import android.graphics.Rect;
26import android.graphics.Region;
27import android.graphics.Region.Op;
28import android.graphics.drawable.Drawable;
29import android.util.AttributeSet;
30import android.view.MotionEvent;
31import android.widget.TextView;
32
33import 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 */
40public 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