src/com/android/launcher3/BubbleTextView.java - platform/packages/apps/Launcher3 - Git at Google

 /*
  * Copyright (C) 2008 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.launcher3;

 import android.animation.ObjectAnimator;
 import android.content.Context;
 import android.content.res.ColorStateList;
 import android.content.res.TypedArray;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Paint;
 import android.graphics.Point;
 import android.graphics.Rect;
 import android.graphics.drawable.ColorDrawable;
 import android.graphics.drawable.Drawable;
 import android.support.v4.graphics.ColorUtils;
 import android.util.AttributeSet;
 import android.util.Property;
 import android.util.TypedValue;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewConfiguration;
 import android.view.ViewDebug;
 import android.view.ViewParent;
 import android.widget.TextView;

 import com.android.launcher3.IconCache.IconLoadRequest;
 import com.android.launcher3.IconCache.ItemInfoUpdateReceiver;
 import com.android.launcher3.badge.BadgeInfo;
 import com.android.launcher3.badge.BadgeRenderer;
 import com.android.launcher3.folder.FolderIcon;
 import com.android.launcher3.folder.FolderIconPreviewVerifier;
 import com.android.launcher3.graphics.DrawableFactory;
 import com.android.launcher3.graphics.HolographicOutlineHelper;
 import com.android.launcher3.graphics.IconPalette;
 import com.android.launcher3.graphics.PreloadIconDrawable;
 import com.android.launcher3.model.PackageItemInfo;

 import java.text.NumberFormat;

 /**
  * TextView that draws a bubble behind the text. We cannot use a LineBackgroundSpan
  * because we want to make the bubble taller than the text and TextView's clip is
  * too aggressive.
  */
 public class BubbleTextView extends TextView implements ItemInfoUpdateReceiver {

     private static final int DISPLAY_WORKSPACE = 0;
     private static final int DISPLAY_ALL_APPS = 1;
     private static final int DISPLAY_FOLDER = 2;

     private static final int[] STATE_PRESSED = new int[] {android.R.attr.state_pressed};

     private final Launcher mLauncher;
     private Drawable mIcon;
     private final boolean mCenterVertically;

     private final CheckLongPressHelper mLongPressHelper;
     private final HolographicOutlineHelper mOutlineHelper;
     private final StylusEventHelper mStylusEventHelper;
     private final float mSlop;

     private Bitmap mPressedBackground;

     private final boolean mDeferShadowGenerationOnTouch;
     private final boolean mLayoutHorizontal;
     private final int mIconSize;
     @ViewDebug.ExportedProperty(category = "launcher")
     private int mTextColor;
     private boolean mIsIconVisible = true;

     private BadgeInfo mBadgeInfo;
     private BadgeRenderer mBadgeRenderer;
     private IconPalette mBadgePalette;
     private float mBadgeScale;
     private boolean mForceHideBadge;
     private Point mTempSpaceForBadgeOffset = new Point();
     private Rect mTempIconBounds = new Rect();

     private static final Property<BubbleTextView, Float> BADGE_SCALE_PROPERTY
             = new Property<BubbleTextView, Float>(Float.TYPE, "badgeScale") {
         @Override
         public Float get(BubbleTextView bubbleTextView) {
             return bubbleTextView.mBadgeScale;
         }

         @Override
         public void set(BubbleTextView bubbleTextView, Float value) {
             bubbleTextView.mBadgeScale = value;
             bubbleTextView.invalidate();
         }
     };

     public static final Property<BubbleTextView, Integer> TEXT_ALPHA_PROPERTY
             = new Property<BubbleTextView, Integer>(Integer.class, "textAlpha") {
         @Override
         public Integer get(BubbleTextView bubbleTextView) {
             return bubbleTextView.getTextAlpha();
         }

         @Override
         public void set(BubbleTextView bubbleTextView, Integer alpha) {
             bubbleTextView.setTextAlpha(alpha);
         }
     };

     @ViewDebug.ExportedProperty(category = "launcher")
     private boolean mStayPressed;
     @ViewDebug.ExportedProperty(category = "launcher")
     private boolean mIgnorePressedStateChange;
     @ViewDebug.ExportedProperty(category = "launcher")
     private boolean mDisableRelayout = false;

     private IconLoadRequest mIconLoadRequest;

     public BubbleTextView(Context context) {
         this(context, null, 0);
     }

     public BubbleTextView(Context context, AttributeSet attrs) {
         this(context, attrs, 0);
     }

     public BubbleTextView(Context context, AttributeSet attrs, int defStyle) {
         super(context, attrs, defStyle);
         mLauncher = Launcher.getLauncher(context);
         DeviceProfile grid = mLauncher.getDeviceProfile();
         mSlop = ViewConfiguration.get(getContext()).getScaledTouchSlop();

         TypedArray a = context.obtainStyledAttributes(attrs,
                 R.styleable.BubbleTextView, defStyle, 0);
         mLayoutHorizontal = a.getBoolean(R.styleable.BubbleTextView_layoutHorizontal, false);
         mDeferShadowGenerationOnTouch =
                 a.getBoolean(R.styleable.BubbleTextView_deferShadowGeneration, false);

         int display = a.getInteger(R.styleable.BubbleTextView_iconDisplay, DISPLAY_WORKSPACE);
         int defaultIconSize = grid.iconSizePx;
         if (display == DISPLAY_WORKSPACE) {
             setTextSize(TypedValue.COMPLEX_UNIT_PX, grid.iconTextSizePx);
             setCompoundDrawablePadding(grid.iconDrawablePaddingPx);
         } else if (display == DISPLAY_ALL_APPS) {
             setTextSize(TypedValue.COMPLEX_UNIT_PX, grid.allAppsIconTextSizePx);
             setCompoundDrawablePadding(grid.allAppsIconDrawablePaddingPx);
             defaultIconSize = grid.allAppsIconSizePx;
         } else if (display == DISPLAY_FOLDER) {
             setTextSize(TypedValue.COMPLEX_UNIT_PX, grid.folderChildTextSizePx);
             setCompoundDrawablePadding(grid.folderChildDrawablePaddingPx);
             defaultIconSize = grid.folderChildIconSizePx;
         }
         mCenterVertically = a.getBoolean(R.styleable.BubbleTextView_centerVertically, false);

         mIconSize = a.getDimensionPixelSize(R.styleable.BubbleTextView_iconSizeOverride,
                 defaultIconSize);
         a.recycle();

         mLongPressHelper = new CheckLongPressHelper(this);
         mStylusEventHelper = new StylusEventHelper(new SimpleOnStylusPressListener(this), this);

         mOutlineHelper = HolographicOutlineHelper.getInstance(getContext());
         setAccessibilityDelegate(mLauncher.getAccessibilityDelegate());

     }

     public void applyFromShortcutInfo(ShortcutInfo info) {
         applyFromShortcutInfo(info, false);
     }

     public void applyFromShortcutInfo(ShortcutInfo info, boolean promiseStateChanged) {
         applyIconAndLabel(info.iconBitmap, info);
         setTag(info);
         if (promiseStateChanged || (info.hasPromiseIconUi())) {
             applyPromiseState(promiseStateChanged);
         }

         applyBadgeState(info, false /* animate */);
     }

     public void applyFromApplicationInfo(AppInfo info) {
         applyIconAndLabel(info.iconBitmap, info);

         // We don't need to check the info since it's not a ShortcutInfo
         super.setTag(info);

         // Verify high res immediately
         verifyHighRes();

         if (info instanceof PromiseAppInfo) {
             PromiseAppInfo promiseAppInfo = (PromiseAppInfo) info;
             applyProgressLevel(promiseAppInfo.level);
         }
         applyBadgeState(info, false /* animate */);
     }

     public void applyFromPackageItemInfo(PackageItemInfo info) {
         applyIconAndLabel(info.iconBitmap, info);
         // We don't need to check the info since it's not a ShortcutInfo
         super.setTag(info);

         // Verify high res immediately
         verifyHighRes();
     }

     private void applyIconAndLabel(Bitmap icon, ItemInfo info) {
         FastBitmapDrawable iconDrawable = DrawableFactory.get(getContext()).newIcon(icon, info);
         iconDrawable.setIsDisabled(info.isDisabled());
         setIcon(iconDrawable);
         setText(info.title);
         if (info.contentDescription != null) {
             setContentDescription(info.isDisabled()
                     ? getContext().getString(R.string.disabled_app_label, info.contentDescription)
                     : info.contentDescription);
         }
     }

     /**
      * Overrides the default long press timeout.
      */
     public void setLongPressTimeout(int longPressTimeout) {
         mLongPressHelper.setLongPressTimeout(longPressTimeout);
     }

     @Override
     public void setTag(Object tag) {
         if (tag != null) {
             LauncherModel.checkItemInfo((ItemInfo) tag);
         }
         super.setTag(tag);
     }

     @Override
     public void refreshDrawableState() {
         if (!mIgnorePressedStateChange) {
             super.refreshDrawableState();
         }
     }

     @Override
     protected int[] onCreateDrawableState(int extraSpace) {
         final int[] drawableState = super.onCreateDrawableState(extraSpace + 1);
         if (mStayPressed) {
             mergeDrawableStates(drawableState, STATE_PRESSED);
         }
         return drawableState;
     }

     /** Returns the icon for this view. */
     public Drawable getIcon() {
         return mIcon;
     }

     @Override
     public boolean onTouchEvent(MotionEvent event) {
         // Call the superclass onTouchEvent first, because sometimes it changes the state to
         // isPressed() on an ACTION_UP
         boolean result = super.onTouchEvent(event);

         // Check for a stylus button press, if it occurs cancel any long press checks.
         if (mStylusEventHelper.onMotionEvent(event)) {
             mLongPressHelper.cancelLongPress();
             result = true;
         }

         switch (event.getAction()) {
             case MotionEvent.ACTION_DOWN:
                 // So that the pressed outline is visible immediately on setStayPressed(),
                 // we pre-create it on ACTION_DOWN (it takes a small but perceptible amount of time
                 // to create it)
                 if (!mDeferShadowGenerationOnTouch && mPressedBackground == null) {
                     mPressedBackground = mOutlineHelper.createMediumDropShadow(this);
                 }

                 // If we're in a stylus button press, don't check for long press.
                 if (!mStylusEventHelper.inStylusButtonPressed()) {
                     mLongPressHelper.postCheckForLongPress();
                 }
                 break;
             case MotionEvent.ACTION_CANCEL:
             case MotionEvent.ACTION_UP:
                 // If we've touched down and up on an item, and it's still not "pressed", then
                 // destroy the pressed outline
                 if (!isPressed()) {
                     mPressedBackground = null;
                 }

                 mLongPressHelper.cancelLongPress();
                 break;
             case MotionEvent.ACTION_MOVE:
                 if (!Utilities.pointInView(this, event.getX(), event.getY(), mSlop)) {
                     mLongPressHelper.cancelLongPress();
                 }
                 break;
         }
         return result;
     }

     void setStayPressed(boolean stayPressed) {
         mStayPressed = stayPressed;
         if (!stayPressed) {
             HolographicOutlineHelper.getInstance(getContext()).recycleShadowBitmap(mPressedBackground);
             mPressedBackground = null;
         } else {
             if (mPressedBackground == null) {
                 mPressedBackground = mOutlineHelper.createMediumDropShadow(this);
             }
         }

         // Only show the shadow effect when persistent pressed state is set.
         ViewParent parent = getParent();
         if (parent != null && parent.getParent() instanceof BubbleTextShadowHandler) {
             ((BubbleTextShadowHandler) parent.getParent()).setPressedIcon(
                     this, mPressedBackground);
         }

         refreshDrawableState();
     }

     void clearPressedBackground() {
         setPressed(false);
         setStayPressed(false);
     }

     @Override
     public boolean onKeyDown(int keyCode, KeyEvent event) {
         if (super.onKeyDown(keyCode, event)) {
             // Pre-create shadow so show immediately on click.
             if (mPressedBackground == null) {
                 mPressedBackground = mOutlineHelper.createMediumDropShadow(this);
             }
             return true;
         }
         return false;
     }

     @Override
     public boolean onKeyUp(int keyCode, KeyEvent event) {
         // Unlike touch events, keypress event propagate pressed state change immediately,
         // without waiting for onClickHandler to execute. Disable pressed state changes here
         // to avoid flickering.
         mIgnorePressedStateChange = true;
         boolean result = super.onKeyUp(keyCode, event);

         mPressedBackground = null;
         mIgnorePressedStateChange = false;
         refreshDrawableState();
         return result;
     }

     @SuppressWarnings("wrongcall")
     protected void drawWithoutBadge(Canvas canvas) {
         super.onDraw(canvas);
     }

     @Override
     public void onDraw(Canvas canvas) {
         super.onDraw(canvas);
         drawBadgeIfNecessary(canvas);
     }

     /**
      * Draws the icon badge in the top right corner of the icon bounds.
      * @param canvas The canvas to draw to.
      */
     protected void drawBadgeIfNecessary(Canvas canvas) {
         if (!mForceHideBadge && (hasBadge() || mBadgeScale > 0)) {
             getIconBounds(mTempIconBounds);
             mTempSpaceForBadgeOffset.set((getWidth() - mIconSize) / 2, getPaddingTop());
             final int scrollX = getScrollX();
             final int scrollY = getScrollY();
             canvas.translate(scrollX, scrollY);
             mBadgeRenderer.draw(canvas, mBadgePalette, mBadgeInfo, mTempIconBounds, mBadgeScale,
                     mTempSpaceForBadgeOffset);
             canvas.translate(-scrollX, -scrollY);
         }
     }

     public void forceHideBadge(boolean forceHideBadge) {
         if (mForceHideBadge == forceHideBadge) {
             return;
         }
         mForceHideBadge = forceHideBadge;

         if (forceHideBadge) {
             invalidate();
         } else if (hasBadge()) {
             ObjectAnimator.ofFloat(this, BADGE_SCALE_PROPERTY, 0, 1).start();
         }
     }

     private boolean hasBadge() {
         return mBadgeInfo != null;
     }

     public void getIconBounds(Rect outBounds) {
         int top = getPaddingTop();
         int left = (getWidth() - mIconSize) / 2;
         int right = left + mIconSize;
         int bottom = top + mIconSize;
         outBounds.set(left, top, right, bottom);
     }

     @Override
     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
         if (mCenterVertically) {
             Paint.FontMetrics fm = getPaint().getFontMetrics();
             int cellHeightPx = mIconSize + getCompoundDrawablePadding() +
                     (int) Math.ceil(fm.bottom - fm.top);
             int height = MeasureSpec.getSize(heightMeasureSpec);
             setPadding(getPaddingLeft(), (height - cellHeightPx) / 2, getPaddingRight(),
                     getPaddingBottom());
         }
         super.onMeasure(widthMeasureSpec, heightMeasureSpec);
     }

     @Override
     public void setTextColor(int color) {
         mTextColor = color;
         super.setTextColor(color);
     }

     @Override
     public void setTextColor(ColorStateList colors) {
         mTextColor = colors.getDefaultColor();
         super.setTextColor(colors);
     }

     public boolean shouldTextBeVisible() {
         // Text should be visible everywhere but the hotseat.
         Object tag = getParent() instanceof FolderIcon ? ((View) getParent()).getTag() : getTag();
         ItemInfo info = tag instanceof ItemInfo ? (ItemInfo) tag : null;
         return info == null || info.container != LauncherSettings.Favorites.CONTAINER_HOTSEAT;
     }

     public void setTextVisibility(boolean visible) {
         if (visible) {
             super.setTextColor(mTextColor);
         } else {
             setTextAlpha(0);
         }
     }

     private void setTextAlpha(int alpha) {
         super.setTextColor(ColorUtils.setAlphaComponent(mTextColor, alpha));
     }

     private int getTextAlpha() {
         return Color.alpha(getCurrentTextColor());
     }

     /**
      * Creates an animator to fade the text in or out.
      * @param fadeIn Whether the text should fade in or fade out.
      */
     public ObjectAnimator createTextAlphaAnimator(boolean fadeIn) {
         int toAlpha = shouldTextBeVisible() && fadeIn ? Color.alpha(mTextColor) : 0;
         return ObjectAnimator.ofInt(this, TEXT_ALPHA_PROPERTY, toAlpha);
     }

     @Override
     public void cancelLongPress() {
         super.cancelLongPress();

         mLongPressHelper.cancelLongPress();
     }

     public void applyPromiseState(boolean promiseStateChanged) {
         if (getTag() instanceof ShortcutInfo) {
             ShortcutInfo info = (ShortcutInfo) getTag();
             final boolean isPromise = info.hasPromiseIconUi();
             final int progressLevel = isPromise ?
                     ((info.hasStatusFlag(ShortcutInfo.FLAG_INSTALL_SESSION_ACTIVE) ?
                             info.getInstallProgress() : 0)) : 100;

             PreloadIconDrawable preloadDrawable = applyProgressLevel(progressLevel);
             if (preloadDrawable != null && promiseStateChanged) {
                 preloadDrawable.maybePerformFinishedAnimation();
             }
         }
     }

     public PreloadIconDrawable applyProgressLevel(int progressLevel) {
         if (getTag() instanceof ItemInfoWithIcon) {
             ItemInfoWithIcon info = (ItemInfoWithIcon) getTag();
             setContentDescription(progressLevel > 0
                     ? getContext().getString(R.string.app_downloading_title, info.title,
                     NumberFormat.getPercentInstance().format(progressLevel * 0.01))
                     : getContext().getString(R.string.app_waiting_download_title, info.title));

             if (mIcon != null) {
                 final PreloadIconDrawable preloadDrawable;
                 if (mIcon instanceof PreloadIconDrawable) {
                     preloadDrawable = (PreloadIconDrawable) mIcon;
                     preloadDrawable.setLevel(progressLevel);
                 } else {
                     preloadDrawable = DrawableFactory.get(getContext())
                             .newPendingIcon(info.iconBitmap, getContext());
                     preloadDrawable.setLevel(progressLevel);
                     setIcon(preloadDrawable);
                 }
                 return preloadDrawable;
             }
         }
         return null;
     }

     public void applyBadgeState(ItemInfo itemInfo, boolean animate) {
         if (mIcon instanceof FastBitmapDrawable) {
             boolean wasBadged = mBadgeInfo != null;
             mBadgeInfo = mLauncher.getPopupDataProvider().getBadgeInfoForItem(itemInfo);
             boolean isBadged = mBadgeInfo != null;
             float newBadgeScale = isBadged ? 1f : 0;
             mBadgeRenderer = mLauncher.getDeviceProfile().mBadgeRenderer;
             if (wasBadged || isBadged) {
                 mBadgePalette = IconPalette.getBadgePalette(getResources());
                 if (mBadgePalette == null) {
                     mBadgePalette = ((FastBitmapDrawable) mIcon).getIconPalette();
                 }
                 // Animate when a badge is first added or when it is removed.
                 if (animate && (wasBadged ^ isBadged) && isShown()) {
                     ObjectAnimator.ofFloat(this, BADGE_SCALE_PROPERTY, newBadgeScale).start();
                 } else {
                     mBadgeScale = newBadgeScale;
                     invalidate();
                 }
             }
         }
     }

     public IconPalette getBadgePalette() {
         return mBadgePalette;
     }

     /**
      * Sets the icon for this view based on the layout direction.
      */
     private void setIcon(Drawable icon) {
         mIcon = icon;
         mIcon.setBounds(0, 0, mIconSize, mIconSize);
         if (mIsIconVisible) {
             applyCompoundDrawables(mIcon);
         }
     }

     public void setIconVisible(boolean visible) {
         mIsIconVisible = visible;
         mDisableRelayout = true;
         Drawable icon = mIcon;
         if (!visible) {
             icon = new ColorDrawable(Color.TRANSPARENT);
             icon.setBounds(0, 0, mIconSize, mIconSize);
         }
         applyCompoundDrawables(icon);
         mDisableRelayout = false;
     }

     protected void applyCompoundDrawables(Drawable icon) {
         if (mLayoutHorizontal) {
             setCompoundDrawablesRelative(icon, null, null, null);
         } else {
             setCompoundDrawables(null, icon, null, null);
         }
     }

     @Override
     public void requestLayout() {
         if (!mDisableRelayout) {
             super.requestLayout();
         }
     }

     /**
      * Applies the item info if it is same as what the view is pointing to currently.
      */
     @Override
     public void reapplyItemInfo(ItemInfoWithIcon info) {
         if (getTag() == info) {
             mIconLoadRequest = null;
             mDisableRelayout = true;

             // Optimization: Starting in N, pre-uploads the bitmap to RenderThread.
             info.iconBitmap.prepareToDraw();

             if (info instanceof AppInfo) {
                 applyFromApplicationInfo((AppInfo) info);
             } else if (info instanceof ShortcutInfo) {
                 applyFromShortcutInfo((ShortcutInfo) info);
                 FolderIconPreviewVerifier verifier =
                         new FolderIconPreviewVerifier(mLauncher.getDeviceProfile().inv);
                 if (verifier.isItemInPreview(info.rank) && (info.container >= 0)) {
                     View folderIcon =
                             mLauncher.getWorkspace().getHomescreenIconByItemId(info.container);
                     if (folderIcon != null) {
                         folderIcon.invalidate();
                     }
                 }
             } else if (info instanceof PackageItemInfo) {
                 applyFromPackageItemInfo((PackageItemInfo) info);
             }

             mDisableRelayout = false;
         }
     }

     /**
      * Verifies that the current icon is high-res otherwise posts a request to load the icon.
      */
     public void verifyHighRes() {
         if (mIconLoadRequest != null) {
             mIconLoadRequest.cancel();
             mIconLoadRequest = null;
         }
         if (getTag() instanceof ItemInfoWithIcon) {
             ItemInfoWithIcon info = (ItemInfoWithIcon) getTag();
             if (info.usingLowResIcon) {
                 mIconLoadRequest = LauncherAppState.getInstance(getContext()).getIconCache()
                         .updateIconInBackground(BubbleTextView.this, info);
             }
         }
     }

     public int getIconSize() {
         return mIconSize;
     }

     /**
      * Interface to be implemented by the grand parent to allow click shadow effect.
      */
     public interface BubbleTextShadowHandler {
         void setPressedIcon(BubbleTextView icon, Bitmap background);
     }
 }
	/*
	* Copyright (C) 2008 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.launcher3;

	import android.animation.ObjectAnimator;
	import android.content.Context;
	import android.content.res.ColorStateList;
	import android.content.res.TypedArray;
	import android.graphics.Bitmap;
	import android.graphics.Canvas;
	import android.graphics.Color;
	import android.graphics.Paint;
	import android.graphics.Point;
	import android.graphics.Rect;
	import android.graphics.drawable.ColorDrawable;
	import android.graphics.drawable.Drawable;
	import android.support.v4.graphics.ColorUtils;
	import android.util.AttributeSet;
	import android.util.Property;
	import android.util.TypedValue;
	import android.view.KeyEvent;
	import android.view.MotionEvent;
	import android.view.View;
	import android.view.ViewConfiguration;
	import android.view.ViewDebug;
	import android.view.ViewParent;
	import android.widget.TextView;

	import com.android.launcher3.IconCache.IconLoadRequest;
	import com.android.launcher3.IconCache.ItemInfoUpdateReceiver;
	import com.android.launcher3.badge.BadgeInfo;
	import com.android.launcher3.badge.BadgeRenderer;
	import com.android.launcher3.folder.FolderIcon;
	import com.android.launcher3.folder.FolderIconPreviewVerifier;
	import com.android.launcher3.graphics.DrawableFactory;
	import com.android.launcher3.graphics.HolographicOutlineHelper;
	import com.android.launcher3.graphics.IconPalette;
	import com.android.launcher3.graphics.PreloadIconDrawable;
	import com.android.launcher3.model.PackageItemInfo;

	import java.text.NumberFormat;

	/**
	* TextView that draws a bubble behind the text. We cannot use a LineBackgroundSpan
	* because we want to make the bubble taller than the text and TextView's clip is
	* too aggressive.
	*/
	public class BubbleTextView extends TextView implements ItemInfoUpdateReceiver {

	private static final int DISPLAY_WORKSPACE = 0;
	private static final int DISPLAY_ALL_APPS = 1;
	private static final int DISPLAY_FOLDER = 2;

	private static final int[] STATE_PRESSED = new int[] {android.R.attr.state_pressed};

	private final Launcher mLauncher;
	private Drawable mIcon;
	private final boolean mCenterVertically;

	private final CheckLongPressHelper mLongPressHelper;
	private final HolographicOutlineHelper mOutlineHelper;
	private final StylusEventHelper mStylusEventHelper;
	private final float mSlop;

	private Bitmap mPressedBackground;

	private final boolean mDeferShadowGenerationOnTouch;
	private final boolean mLayoutHorizontal;
	private final int mIconSize;
	@ViewDebug.ExportedProperty(category = "launcher")
	private int mTextColor;
	private boolean mIsIconVisible = true;

	private BadgeInfo mBadgeInfo;
	private BadgeRenderer mBadgeRenderer;
	private IconPalette mBadgePalette;
	private float mBadgeScale;
	private boolean mForceHideBadge;
	private Point mTempSpaceForBadgeOffset = new Point();
	private Rect mTempIconBounds = new Rect();

	private static final Property<BubbleTextView, Float> BADGE_SCALE_PROPERTY
	= new Property<BubbleTextView, Float>(Float.TYPE, "badgeScale") {
	@Override
	public Float get(BubbleTextView bubbleTextView) {
	return bubbleTextView.mBadgeScale;
	}

	@Override
	public void set(BubbleTextView bubbleTextView, Float value) {
	bubbleTextView.mBadgeScale = value;
	bubbleTextView.invalidate();
	}
	};

	public static final Property<BubbleTextView, Integer> TEXT_ALPHA_PROPERTY
	= new Property<BubbleTextView, Integer>(Integer.class, "textAlpha") {
	@Override
	public Integer get(BubbleTextView bubbleTextView) {
	return bubbleTextView.getTextAlpha();
	}

	@Override
	public void set(BubbleTextView bubbleTextView, Integer alpha) {
	bubbleTextView.setTextAlpha(alpha);
	}
	};

	@ViewDebug.ExportedProperty(category = "launcher")
	private boolean mStayPressed;
	@ViewDebug.ExportedProperty(category = "launcher")
	private boolean mIgnorePressedStateChange;
	@ViewDebug.ExportedProperty(category = "launcher")
	private boolean mDisableRelayout = false;

	private IconLoadRequest mIconLoadRequest;

	public BubbleTextView(Context context) {
	this(context, null, 0);
	}

	public BubbleTextView(Context context, AttributeSet attrs) {
	this(context, attrs, 0);
	}

	public BubbleTextView(Context context, AttributeSet attrs, int defStyle) {
	super(context, attrs, defStyle);
	mLauncher = Launcher.getLauncher(context);
	DeviceProfile grid = mLauncher.getDeviceProfile();
	mSlop = ViewConfiguration.get(getContext()).getScaledTouchSlop();

	TypedArray a = context.obtainStyledAttributes(attrs,
	R.styleable.BubbleTextView, defStyle, 0);
	mLayoutHorizontal = a.getBoolean(R.styleable.BubbleTextView_layoutHorizontal, false);
	mDeferShadowGenerationOnTouch =
	a.getBoolean(R.styleable.BubbleTextView_deferShadowGeneration, false);

	int display = a.getInteger(R.styleable.BubbleTextView_iconDisplay, DISPLAY_WORKSPACE);
	int defaultIconSize = grid.iconSizePx;
	if (display == DISPLAY_WORKSPACE) {
	setTextSize(TypedValue.COMPLEX_UNIT_PX, grid.iconTextSizePx);
	setCompoundDrawablePadding(grid.iconDrawablePaddingPx);
	} else if (display == DISPLAY_ALL_APPS) {
	setTextSize(TypedValue.COMPLEX_UNIT_PX, grid.allAppsIconTextSizePx);
	setCompoundDrawablePadding(grid.allAppsIconDrawablePaddingPx);
	defaultIconSize = grid.allAppsIconSizePx;
	} else if (display == DISPLAY_FOLDER) {
	setTextSize(TypedValue.COMPLEX_UNIT_PX, grid.folderChildTextSizePx);
	setCompoundDrawablePadding(grid.folderChildDrawablePaddingPx);
	defaultIconSize = grid.folderChildIconSizePx;
	}
	mCenterVertically = a.getBoolean(R.styleable.BubbleTextView_centerVertically, false);

	mIconSize = a.getDimensionPixelSize(R.styleable.BubbleTextView_iconSizeOverride,
	defaultIconSize);
	a.recycle();

	mLongPressHelper = new CheckLongPressHelper(this);
	mStylusEventHelper = new StylusEventHelper(new SimpleOnStylusPressListener(this), this);

	mOutlineHelper = HolographicOutlineHelper.getInstance(getContext());
	setAccessibilityDelegate(mLauncher.getAccessibilityDelegate());

	}

	public void applyFromShortcutInfo(ShortcutInfo info) {
	applyFromShortcutInfo(info, false);
	}

	public void applyFromShortcutInfo(ShortcutInfo info, boolean promiseStateChanged) {
	applyIconAndLabel(info.iconBitmap, info);
	setTag(info);
	if (promiseStateChanged \|\| (info.hasPromiseIconUi())) {
	applyPromiseState(promiseStateChanged);
	}

	applyBadgeState(info, false /* animate */);
	}

	public void applyFromApplicationInfo(AppInfo info) {
	applyIconAndLabel(info.iconBitmap, info);

	// We don't need to check the info since it's not a ShortcutInfo
	super.setTag(info);

	// Verify high res immediately
	verifyHighRes();

	if (info instanceof PromiseAppInfo) {
	PromiseAppInfo promiseAppInfo = (PromiseAppInfo) info;
	applyProgressLevel(promiseAppInfo.level);
	}
	applyBadgeState(info, false /* animate */);
	}

	public void applyFromPackageItemInfo(PackageItemInfo info) {
	applyIconAndLabel(info.iconBitmap, info);
	// We don't need to check the info since it's not a ShortcutInfo
	super.setTag(info);

	// Verify high res immediately
	verifyHighRes();
	}

	private void applyIconAndLabel(Bitmap icon, ItemInfo info) {
	FastBitmapDrawable iconDrawable = DrawableFactory.get(getContext()).newIcon(icon, info);
	iconDrawable.setIsDisabled(info.isDisabled());
	setIcon(iconDrawable);
	setText(info.title);
	if (info.contentDescription != null) {
	setContentDescription(info.isDisabled()
	? getContext().getString(R.string.disabled_app_label, info.contentDescription)
	: info.contentDescription);
	}
	}

	/**
	* Overrides the default long press timeout.
	*/
	public void setLongPressTimeout(int longPressTimeout) {
	mLongPressHelper.setLongPressTimeout(longPressTimeout);
	}

	@Override
	public void setTag(Object tag) {
	if (tag != null) {
	LauncherModel.checkItemInfo((ItemInfo) tag);
	}
	super.setTag(tag);
	}

	@Override
	public void refreshDrawableState() {
	if (!mIgnorePressedStateChange) {
	super.refreshDrawableState();
	}
	}

	@Override
	protected int[] onCreateDrawableState(int extraSpace) {
	final int[] drawableState = super.onCreateDrawableState(extraSpace + 1);
	if (mStayPressed) {
	mergeDrawableStates(drawableState, STATE_PRESSED);
	}
	return drawableState;
	}

	/** Returns the icon for this view. */
	public Drawable getIcon() {
	return mIcon;
	}

	@Override
	public boolean onTouchEvent(MotionEvent event) {
	// Call the superclass onTouchEvent first, because sometimes it changes the state to
	// isPressed() on an ACTION_UP
	boolean result = super.onTouchEvent(event);

	// Check for a stylus button press, if it occurs cancel any long press checks.
	if (mStylusEventHelper.onMotionEvent(event)) {
	mLongPressHelper.cancelLongPress();
	result = true;
	}

	switch (event.getAction()) {
	case MotionEvent.ACTION_DOWN:
	// So that the pressed outline is visible immediately on setStayPressed(),
	// we pre-create it on ACTION_DOWN (it takes a small but perceptible amount of time
	// to create it)
	if (!mDeferShadowGenerationOnTouch && mPressedBackground == null) {
	mPressedBackground = mOutlineHelper.createMediumDropShadow(this);
	}

	// If we're in a stylus button press, don't check for long press.
	if (!mStylusEventHelper.inStylusButtonPressed()) {
	mLongPressHelper.postCheckForLongPress();
	}
	break;
	case MotionEvent.ACTION_CANCEL:
	case MotionEvent.ACTION_UP:
	// If we've touched down and up on an item, and it's still not "pressed", then
	// destroy the pressed outline
	if (!isPressed()) {
	mPressedBackground = null;
	}

	mLongPressHelper.cancelLongPress();
	break;
	case MotionEvent.ACTION_MOVE:
	if (!Utilities.pointInView(this, event.getX(), event.getY(), mSlop)) {
	mLongPressHelper.cancelLongPress();
	}
	break;
	}
	return result;
	}

	void setStayPressed(boolean stayPressed) {
	mStayPressed = stayPressed;
	if (!stayPressed) {
	HolographicOutlineHelper.getInstance(getContext()).recycleShadowBitmap(mPressedBackground);
	mPressedBackground = null;
	} else {
	if (mPressedBackground == null) {
	mPressedBackground = mOutlineHelper.createMediumDropShadow(this);
	}
	}

	// Only show the shadow effect when persistent pressed state is set.
	ViewParent parent = getParent();
	if (parent != null && parent.getParent() instanceof BubbleTextShadowHandler) {
	((BubbleTextShadowHandler) parent.getParent()).setPressedIcon(
	this, mPressedBackground);
	}

	refreshDrawableState();
	}

	void clearPressedBackground() {
	setPressed(false);
	setStayPressed(false);
	}

	@Override
	public boolean onKeyDown(int keyCode, KeyEvent event) {
	if (super.onKeyDown(keyCode, event)) {
	// Pre-create shadow so show immediately on click.
	if (mPressedBackground == null) {
	mPressedBackground = mOutlineHelper.createMediumDropShadow(this);
	}
	return true;
	}
	return false;
	}

	@Override
	public boolean onKeyUp(int keyCode, KeyEvent event) {
	// Unlike touch events, keypress event propagate pressed state change immediately,
	// without waiting for onClickHandler to execute. Disable pressed state changes here
	// to avoid flickering.
	mIgnorePressedStateChange = true;
	boolean result = super.onKeyUp(keyCode, event);

	mPressedBackground = null;
	mIgnorePressedStateChange = false;
	refreshDrawableState();
	return result;
	}

	@SuppressWarnings("wrongcall")
	protected void drawWithoutBadge(Canvas canvas) {
	super.onDraw(canvas);
	}

	@Override
	public void onDraw(Canvas canvas) {
	super.onDraw(canvas);
	drawBadgeIfNecessary(canvas);
	}

	/**
	* Draws the icon badge in the top right corner of the icon bounds.
	* @param canvas The canvas to draw to.
	*/
	protected void drawBadgeIfNecessary(Canvas canvas) {
	if (!mForceHideBadge && (hasBadge() \|\| mBadgeScale > 0)) {
	getIconBounds(mTempIconBounds);
	mTempSpaceForBadgeOffset.set((getWidth() - mIconSize) / 2, getPaddingTop());
	final int scrollX = getScrollX();
	final int scrollY = getScrollY();
	canvas.translate(scrollX, scrollY);
	mBadgeRenderer.draw(canvas, mBadgePalette, mBadgeInfo, mTempIconBounds, mBadgeScale,
	mTempSpaceForBadgeOffset);
	canvas.translate(-scrollX, -scrollY);
	}
	}

	public void forceHideBadge(boolean forceHideBadge) {
	if (mForceHideBadge == forceHideBadge) {
	return;
	}
	mForceHideBadge = forceHideBadge;

	if (forceHideBadge) {
	invalidate();
	} else if (hasBadge()) {
	ObjectAnimator.ofFloat(this, BADGE_SCALE_PROPERTY, 0, 1).start();
	}
	}

	private boolean hasBadge() {
	return mBadgeInfo != null;
	}

	public void getIconBounds(Rect outBounds) {
	int top = getPaddingTop();
	int left = (getWidth() - mIconSize) / 2;
	int right = left + mIconSize;
	int bottom = top + mIconSize;
	outBounds.set(left, top, right, bottom);
	}

	@Override
	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
	if (mCenterVertically) {
	Paint.FontMetrics fm = getPaint().getFontMetrics();
	int cellHeightPx = mIconSize + getCompoundDrawablePadding() +
	(int) Math.ceil(fm.bottom - fm.top);
	int height = MeasureSpec.getSize(heightMeasureSpec);
	setPadding(getPaddingLeft(), (height - cellHeightPx) / 2, getPaddingRight(),
	getPaddingBottom());
	}
	super.onMeasure(widthMeasureSpec, heightMeasureSpec);
	}

	@Override
	public void setTextColor(int color) {
	mTextColor = color;
	super.setTextColor(color);
	}

	@Override
	public void setTextColor(ColorStateList colors) {
	mTextColor = colors.getDefaultColor();
	super.setTextColor(colors);
	}

	public boolean shouldTextBeVisible() {
	// Text should be visible everywhere but the hotseat.
	Object tag = getParent() instanceof FolderIcon ? ((View) getParent()).getTag() : getTag();
	ItemInfo info = tag instanceof ItemInfo ? (ItemInfo) tag : null;
	return info == null \|\| info.container != LauncherSettings.Favorites.CONTAINER_HOTSEAT;
	}

	public void setTextVisibility(boolean visible) {
	if (visible) {
	super.setTextColor(mTextColor);
	} else {
	setTextAlpha(0);
	}
	}

	private void setTextAlpha(int alpha) {
	super.setTextColor(ColorUtils.setAlphaComponent(mTextColor, alpha));
	}

	private int getTextAlpha() {
	return Color.alpha(getCurrentTextColor());
	}

	/**
	* Creates an animator to fade the text in or out.
	* @param fadeIn Whether the text should fade in or fade out.
	*/
	public ObjectAnimator createTextAlphaAnimator(boolean fadeIn) {
	int toAlpha = shouldTextBeVisible() && fadeIn ? Color.alpha(mTextColor) : 0;
	return ObjectAnimator.ofInt(this, TEXT_ALPHA_PROPERTY, toAlpha);
	}

	@Override
	public void cancelLongPress() {
	super.cancelLongPress();

	mLongPressHelper.cancelLongPress();
	}

	public void applyPromiseState(boolean promiseStateChanged) {
	if (getTag() instanceof ShortcutInfo) {
	ShortcutInfo info = (ShortcutInfo) getTag();
	final boolean isPromise = info.hasPromiseIconUi();
	final int progressLevel = isPromise ?
	((info.hasStatusFlag(ShortcutInfo.FLAG_INSTALL_SESSION_ACTIVE) ?
	info.getInstallProgress() : 0)) : 100;

	PreloadIconDrawable preloadDrawable = applyProgressLevel(progressLevel);
	if (preloadDrawable != null && promiseStateChanged) {
	preloadDrawable.maybePerformFinishedAnimation();
	}
	}
	}

	public PreloadIconDrawable applyProgressLevel(int progressLevel) {
	if (getTag() instanceof ItemInfoWithIcon) {
	ItemInfoWithIcon info = (ItemInfoWithIcon) getTag();
	setContentDescription(progressLevel > 0
	? getContext().getString(R.string.app_downloading_title, info.title,
	NumberFormat.getPercentInstance().format(progressLevel * 0.01))
	: getContext().getString(R.string.app_waiting_download_title, info.title));

	if (mIcon != null) {
	final PreloadIconDrawable preloadDrawable;
	if (mIcon instanceof PreloadIconDrawable) {
	preloadDrawable = (PreloadIconDrawable) mIcon;
	preloadDrawable.setLevel(progressLevel);
	} else {
	preloadDrawable = DrawableFactory.get(getContext())
	.newPendingIcon(info.iconBitmap, getContext());
	preloadDrawable.setLevel(progressLevel);
	setIcon(preloadDrawable);
	}
	return preloadDrawable;
	}
	}
	return null;
	}

	public void applyBadgeState(ItemInfo itemInfo, boolean animate) {
	if (mIcon instanceof FastBitmapDrawable) {
	boolean wasBadged = mBadgeInfo != null;
	mBadgeInfo = mLauncher.getPopupDataProvider().getBadgeInfoForItem(itemInfo);
	boolean isBadged = mBadgeInfo != null;
	float newBadgeScale = isBadged ? 1f : 0;
	mBadgeRenderer = mLauncher.getDeviceProfile().mBadgeRenderer;
	if (wasBadged \|\| isBadged) {
	mBadgePalette = IconPalette.getBadgePalette(getResources());
	if (mBadgePalette == null) {
	mBadgePalette = ((FastBitmapDrawable) mIcon).getIconPalette();
	}
	// Animate when a badge is first added or when it is removed.
	if (animate && (wasBadged ^ isBadged) && isShown()) {
	ObjectAnimator.ofFloat(this, BADGE_SCALE_PROPERTY, newBadgeScale).start();
	} else {
	mBadgeScale = newBadgeScale;
	invalidate();
	}
	}
	}
	}

	public IconPalette getBadgePalette() {
	return mBadgePalette;
	}

	/**
	* Sets the icon for this view based on the layout direction.
	*/
	private void setIcon(Drawable icon) {
	mIcon = icon;
	mIcon.setBounds(0, 0, mIconSize, mIconSize);
	if (mIsIconVisible) {
	applyCompoundDrawables(mIcon);
	}
	}

	public void setIconVisible(boolean visible) {
	mIsIconVisible = visible;
	mDisableRelayout = true;
	Drawable icon = mIcon;
	if (!visible) {
	icon = new ColorDrawable(Color.TRANSPARENT);
	icon.setBounds(0, 0, mIconSize, mIconSize);
	}
	applyCompoundDrawables(icon);
	mDisableRelayout = false;
	}

	protected void applyCompoundDrawables(Drawable icon) {
	if (mLayoutHorizontal) {
	setCompoundDrawablesRelative(icon, null, null, null);
	} else {
	setCompoundDrawables(null, icon, null, null);
	}
	}

	@Override
	public void requestLayout() {
	if (!mDisableRelayout) {
	super.requestLayout();
	}
	}

	/**
	* Applies the item info if it is same as what the view is pointing to currently.
	*/
	@Override
	public void reapplyItemInfo(ItemInfoWithIcon info) {
	if (getTag() == info) {
	mIconLoadRequest = null;
	mDisableRelayout = true;

	// Optimization: Starting in N, pre-uploads the bitmap to RenderThread.
	info.iconBitmap.prepareToDraw();

	if (info instanceof AppInfo) {
	applyFromApplicationInfo((AppInfo) info);
	} else if (info instanceof ShortcutInfo) {
	applyFromShortcutInfo((ShortcutInfo) info);
	FolderIconPreviewVerifier verifier =
	new FolderIconPreviewVerifier(mLauncher.getDeviceProfile().inv);
	if (verifier.isItemInPreview(info.rank) && (info.container >= 0)) {
	View folderIcon =
	mLauncher.getWorkspace().getHomescreenIconByItemId(info.container);
	if (folderIcon != null) {
	folderIcon.invalidate();
	}
	}
	} else if (info instanceof PackageItemInfo) {
	applyFromPackageItemInfo((PackageItemInfo) info);
	}

	mDisableRelayout = false;
	}
	}

	/**
	* Verifies that the current icon is high-res otherwise posts a request to load the icon.
	*/
	public void verifyHighRes() {
	if (mIconLoadRequest != null) {
	mIconLoadRequest.cancel();
	mIconLoadRequest = null;
	}
	if (getTag() instanceof ItemInfoWithIcon) {
	ItemInfoWithIcon info = (ItemInfoWithIcon) getTag();
	if (info.usingLowResIcon) {
	mIconLoadRequest = LauncherAppState.getInstance(getContext()).getIconCache()
	.updateIconInBackground(BubbleTextView.this, info);
	}
	}
	}

	public int getIconSize() {
	return mIconSize;
	}

	/**
	* Interface to be implemented by the grand parent to allow click shadow effect.
	*/
	public interface BubbleTextShadowHandler {
	void setPressedIcon(BubbleTextView icon, Bitmap background);
	}
	}