mirror of
https://github.com/LawnchairLauncher/lawnchair.git
synced 2026-03-01 00:06:47 +00:00
1f3f07d47c
> Replacing some colors with theme attributes > Simplifying styles definition by removing unnecessary inheritance and inlining some definitions Change-Id: Ifa167515cae6a7fd3720f1a52ff9ce11abb4495f
654 lines
24 KiB
Java
654 lines
24 KiB
Java
/*
|
|
* 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.content.Context;
|
|
import android.content.res.ColorStateList;
|
|
import android.content.res.Resources;
|
|
import android.content.res.TypedArray;
|
|
import android.graphics.Bitmap;
|
|
import android.graphics.Canvas;
|
|
import android.graphics.Paint;
|
|
import android.graphics.Region;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.util.AttributeSet;
|
|
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.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 BaseRecyclerViewFastScrollBar.FastScrollFocusableView, ItemInfoUpdateReceiver {
|
|
|
|
// Dimensions in DP
|
|
private static final float AMBIENT_SHADOW_RADIUS = 2.5f;
|
|
private static final float KEY_SHADOW_RADIUS = 1f;
|
|
private static final float KEY_SHADOW_OFFSET = 0.5f;
|
|
private static final int AMBIENT_SHADOW_COLOR = 0x33000000;
|
|
private static final int KEY_SHADOW_COLOR = 0x66000000;
|
|
|
|
private static final int DISPLAY_WORKSPACE = 0;
|
|
private static final int DISPLAY_ALL_APPS = 1;
|
|
private static final int DISPLAY_FOLDER = 2;
|
|
|
|
private final Launcher mLauncher;
|
|
private Drawable mIcon;
|
|
private final boolean mCenterVertically;
|
|
private final Drawable mBackground;
|
|
private OnLongClickListener mOnLongClickListener;
|
|
private final CheckLongPressHelper mLongPressHelper;
|
|
private final HolographicOutlineHelper mOutlineHelper;
|
|
private final StylusEventHelper mStylusEventHelper;
|
|
|
|
private boolean mBackgroundSizeChanged;
|
|
|
|
private Bitmap mPressedBackground;
|
|
|
|
private float mSlop;
|
|
|
|
private final boolean mDeferShadowGenerationOnTouch;
|
|
private final boolean mCustomShadowsEnabled;
|
|
private final boolean mLayoutHorizontal;
|
|
private final int mIconSize;
|
|
@ViewDebug.ExportedProperty(category = "launcher")
|
|
private int mTextColor;
|
|
|
|
@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();
|
|
|
|
TypedArray a = context.obtainStyledAttributes(attrs,
|
|
R.styleable.BubbleTextView, defStyle, 0);
|
|
mCustomShadowsEnabled = a.getBoolean(R.styleable.BubbleTextView_customShadows, false);
|
|
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);
|
|
} 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();
|
|
|
|
if (mCustomShadowsEnabled) {
|
|
// Draw the background itself as the parent is drawn twice.
|
|
mBackground = getBackground();
|
|
setBackground(null);
|
|
|
|
// Set shadow layer as the larger shadow to that the textView does not clip the shadow.
|
|
float density = getResources().getDisplayMetrics().density;
|
|
setShadowLayer(density * AMBIENT_SHADOW_RADIUS, 0, 0, AMBIENT_SHADOW_COLOR);
|
|
} else {
|
|
mBackground = null;
|
|
}
|
|
|
|
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.isPromise()) {
|
|
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();
|
|
|
|
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
|
|
protected boolean setFrame(int left, int top, int right, int bottom) {
|
|
if (getLeft() != left || getRight() != right || getTop() != top || getBottom() != bottom) {
|
|
mBackgroundSizeChanged = true;
|
|
}
|
|
return super.setFrame(left, top, right, bottom);
|
|
}
|
|
|
|
@Override
|
|
protected boolean verifyDrawable(Drawable who) {
|
|
return who == mBackground || super.verifyDrawable(who);
|
|
}
|
|
|
|
@Override
|
|
public void setTag(Object tag) {
|
|
if (tag != null) {
|
|
LauncherModel.checkItemInfo((ItemInfo) tag);
|
|
}
|
|
super.setTag(tag);
|
|
}
|
|
|
|
@Override
|
|
public void setPressed(boolean pressed) {
|
|
super.setPressed(pressed);
|
|
|
|
if (!mIgnorePressedStateChange) {
|
|
updateIconState();
|
|
}
|
|
}
|
|
|
|
/** Returns the icon for this view. */
|
|
public Drawable getIcon() {
|
|
return mIcon;
|
|
}
|
|
|
|
/** Returns whether the layout is horizontal. */
|
|
public boolean isLayoutHorizontal() {
|
|
return mLayoutHorizontal;
|
|
}
|
|
|
|
private void updateIconState() {
|
|
if (mIcon instanceof FastBitmapDrawable) {
|
|
FastBitmapDrawable d = (FastBitmapDrawable) mIcon;
|
|
if (isPressed() || mStayPressed) {
|
|
d.animateState(FastBitmapDrawable.State.PRESSED);
|
|
} else {
|
|
d.animateState(FastBitmapDrawable.State.NORMAL);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void setOnLongClickListener(OnLongClickListener l) {
|
|
super.setOnLongClickListener(l);
|
|
mOnLongClickListener = l;
|
|
}
|
|
|
|
public OnLongClickListener getOnLongClickListener() {
|
|
return mOnLongClickListener;
|
|
}
|
|
|
|
@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);
|
|
}
|
|
|
|
updateIconState();
|
|
}
|
|
|
|
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;
|
|
updateIconState();
|
|
return result;
|
|
}
|
|
|
|
@Override
|
|
public void draw(Canvas canvas) {
|
|
if (!mCustomShadowsEnabled) {
|
|
super.draw(canvas);
|
|
return;
|
|
}
|
|
|
|
final Drawable background = mBackground;
|
|
if (background != null) {
|
|
final int scrollX = getScrollX();
|
|
final int scrollY = getScrollY();
|
|
|
|
if (mBackgroundSizeChanged) {
|
|
background.setBounds(0, 0, getRight() - getLeft(), getBottom() - getTop());
|
|
mBackgroundSizeChanged = false;
|
|
}
|
|
|
|
if ((scrollX | scrollY) == 0) {
|
|
background.draw(canvas);
|
|
} else {
|
|
canvas.translate(scrollX, scrollY);
|
|
background.draw(canvas);
|
|
canvas.translate(-scrollX, -scrollY);
|
|
}
|
|
}
|
|
|
|
// If text is transparent, don't draw any shadow
|
|
if ((getCurrentTextColor() >> 24) == 0) {
|
|
getPaint().clearShadowLayer();
|
|
super.draw(canvas);
|
|
return;
|
|
}
|
|
|
|
// We enhance the shadow by drawing the shadow twice
|
|
float density = getResources().getDisplayMetrics().density;
|
|
getPaint().setShadowLayer(density * AMBIENT_SHADOW_RADIUS, 0, 0, AMBIENT_SHADOW_COLOR);
|
|
super.draw(canvas);
|
|
canvas.save(Canvas.CLIP_SAVE_FLAG);
|
|
canvas.clipRect(getScrollX(), getScrollY() + getExtendedPaddingTop(),
|
|
getScrollX() + getWidth(),
|
|
getScrollY() + getHeight(), Region.Op.INTERSECT);
|
|
getPaint().setShadowLayer(
|
|
density * KEY_SHADOW_RADIUS, 0.0f, density * KEY_SHADOW_OFFSET, KEY_SHADOW_COLOR);
|
|
super.draw(canvas);
|
|
canvas.restore();
|
|
}
|
|
|
|
@Override
|
|
protected void onAttachedToWindow() {
|
|
super.onAttachedToWindow();
|
|
|
|
if (mBackground != null) mBackground.setCallback(this);
|
|
mSlop = ViewConfiguration.get(getContext()).getScaledTouchSlop();
|
|
}
|
|
|
|
@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
|
|
protected void onDetachedFromWindow() {
|
|
super.onDetachedFromWindow();
|
|
if (mBackground != null) mBackground.setCallback(null);
|
|
}
|
|
|
|
@Override
|
|
public void setTextColor(int color) {
|
|
mTextColor = color;
|
|
super.setTextColor(color);
|
|
}
|
|
|
|
@Override
|
|
public void setTextColor(ColorStateList colors) {
|
|
mTextColor = colors.getDefaultColor();
|
|
super.setTextColor(colors);
|
|
}
|
|
|
|
public void setTextVisibility(boolean visible) {
|
|
Resources res = getResources();
|
|
if (visible) {
|
|
super.setTextColor(mTextColor);
|
|
} else {
|
|
super.setTextColor(res.getColor(android.R.color.transparent));
|
|
}
|
|
}
|
|
|
|
@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.isPromise();
|
|
final int progressLevel = isPromise ?
|
|
((info.hasStatusFlag(ShortcutInfo.FLAG_INSTALL_SESSION_ACTIVE) ?
|
|
info.getInstallProgress() : 0)) : 100;
|
|
|
|
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;
|
|
} else {
|
|
preloadDrawable = DrawableFactory.get(getContext())
|
|
.newPendingIcon(info.iconBitmap, getContext());
|
|
setIcon(preloadDrawable);
|
|
}
|
|
|
|
preloadDrawable.setLevel(progressLevel);
|
|
if (promiseStateChanged) {
|
|
preloadDrawable.maybePerformFinishedAnimation();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void applyBadgeState(ItemInfo itemInfo, boolean animate) {
|
|
if (mIcon instanceof FastBitmapDrawable) {
|
|
BadgeInfo badgeInfo = mLauncher.getPopupDataProvider().getBadgeInfoForItem(itemInfo);
|
|
BadgeRenderer badgeRenderer = mLauncher.getDeviceProfile().mBadgeRenderer;
|
|
((FastBitmapDrawable) mIcon).applyIconBadge(badgeInfo, badgeRenderer, animate);
|
|
}
|
|
}
|
|
|
|
public IconPalette getIconPalette() {
|
|
return mIcon instanceof FastBitmapDrawable ? ((FastBitmapDrawable) mIcon).getIconPalette()
|
|
: null;
|
|
}
|
|
|
|
/**
|
|
* Sets the icon for this view based on the layout direction.
|
|
*/
|
|
private void setIcon(Drawable icon) {
|
|
mIcon = icon;
|
|
mIcon.setBounds(0, 0, mIconSize, mIconSize);
|
|
applyCompoundDrawables(mIcon);
|
|
}
|
|
|
|
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) {
|
|
FastBitmapDrawable.State prevState = FastBitmapDrawable.State.NORMAL;
|
|
if (mIcon instanceof FastBitmapDrawable) {
|
|
prevState = ((FastBitmapDrawable) mIcon).getCurrentState();
|
|
}
|
|
mIconLoadRequest = null;
|
|
mDisableRelayout = true;
|
|
|
|
if (info instanceof AppInfo) {
|
|
applyFromApplicationInfo((AppInfo) info);
|
|
} else if (info instanceof ShortcutInfo) {
|
|
applyFromShortcutInfo((ShortcutInfo) info);
|
|
if ((info.rank < FolderIcon.NUM_ITEMS_IN_PREVIEW) && (info.container >= 0)) {
|
|
View folderIcon =
|
|
mLauncher.getWorkspace().getHomescreenIconByItemId(info.container);
|
|
if (folderIcon != null) {
|
|
folderIcon.invalidate();
|
|
}
|
|
}
|
|
} else if (info instanceof PackageItemInfo) {
|
|
applyFromPackageItemInfo((PackageItemInfo) info);
|
|
}
|
|
|
|
// If we are reapplying over an old icon, then we should update the new icon to the same
|
|
// state as the old icon
|
|
if (mIcon instanceof FastBitmapDrawable) {
|
|
((FastBitmapDrawable) mIcon).setState(prevState);
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void setFastScrollFocusState(final FastBitmapDrawable.State focusState, boolean animated) {
|
|
// We can only set the fast scroll focus state on a FastBitmapDrawable
|
|
if (!(mIcon instanceof FastBitmapDrawable)) {
|
|
return;
|
|
}
|
|
|
|
FastBitmapDrawable d = (FastBitmapDrawable) mIcon;
|
|
if (animated) {
|
|
FastBitmapDrawable.State prevState = d.getCurrentState();
|
|
if (d.animateState(focusState)) {
|
|
// If the state was updated, then update the view accordingly
|
|
animate().scaleX(focusState.viewScale)
|
|
.scaleY(focusState.viewScale)
|
|
.setStartDelay(getStartDelayForStateChange(prevState, focusState))
|
|
.setDuration(d.getDurationForStateChange(prevState, focusState))
|
|
.start();
|
|
}
|
|
} else {
|
|
if (d.setState(focusState)) {
|
|
// If the state was updated, then update the view accordingly
|
|
animate().cancel();
|
|
setScaleX(focusState.viewScale);
|
|
setScaleY(focusState.viewScale);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true if the view can show custom shortcuts.
|
|
*/
|
|
public boolean hasDeepShortcuts() {
|
|
return !mLauncher.getPopupDataProvider().getShortcutIdsForItem((ItemInfo) getTag())
|
|
.isEmpty();
|
|
}
|
|
|
|
/**
|
|
* Returns the start delay when animating between certain {@link FastBitmapDrawable} states.
|
|
*/
|
|
private static int getStartDelayForStateChange(final FastBitmapDrawable.State fromState,
|
|
final FastBitmapDrawable.State toState) {
|
|
switch (toState) {
|
|
case NORMAL:
|
|
switch (fromState) {
|
|
case FAST_SCROLL_HIGHLIGHTED:
|
|
return FastBitmapDrawable.FAST_SCROLL_INACTIVE_DURATION / 4;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Interface to be implemented by the grand parent to allow click shadow effect.
|
|
*/
|
|
public interface BubbleTextShadowHandler {
|
|
void setPressedIcon(BubbleTextView icon, Bitmap background);
|
|
}
|
|
}
|