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.launcher3; 18 19 import android.annotation.TargetApi; 20 import android.content.Context; 21 import android.content.res.ColorStateList; 22 import android.content.res.Resources; 23 import android.content.res.Resources.Theme; 24 import android.content.res.TypedArray; 25 import android.graphics.Bitmap; 26 import android.graphics.Canvas; 27 import android.graphics.Paint; 28 import android.graphics.Region; 29 import android.graphics.drawable.ColorDrawable; 30 import android.graphics.drawable.Drawable; 31 import android.os.Build; 32 import android.util.AttributeSet; 33 import android.util.SparseArray; 34 import android.util.TypedValue; 35 import android.view.KeyEvent; 36 import android.view.MotionEvent; 37 import android.view.View; 38 import android.view.ViewConfiguration; 39 import android.view.ViewDebug; 40 import android.view.ViewParent; 41 import android.widget.TextView; 42 43 import com.android.launcher3.IconCache.IconLoadRequest; 44 import com.android.launcher3.folder.FolderIcon; 45 import com.android.launcher3.model.PackageItemInfo; 46 47 import java.text.NumberFormat; 48 49 /** 50 * TextView that draws a bubble behind the text. We cannot use a LineBackgroundSpan 51 * because we want to make the bubble taller than the text and TextView's clip is 52 * too aggressive. 53 */ 54 public class BubbleTextView extends TextView 55 implements BaseRecyclerViewFastScrollBar.FastScrollFocusableView { 56 57 private static SparseArray<Theme> sPreloaderThemes = new SparseArray<Theme>(2); 58 59 // Dimensions in DP 60 private static final float AMBIENT_SHADOW_RADIUS = 2.5f; 61 private static final float KEY_SHADOW_RADIUS = 1f; 62 private static final float KEY_SHADOW_OFFSET = 0.5f; 63 private static final int AMBIENT_SHADOW_COLOR = 0x33000000; 64 private static final int KEY_SHADOW_COLOR = 0x66000000; 65 66 private static final int DISPLAY_WORKSPACE = 0; 67 private static final int DISPLAY_ALL_APPS = 1; 68 private static final int DISPLAY_FOLDER = 2; 69 70 private final Launcher mLauncher; 71 private Drawable mIcon; 72 private final boolean mCenterVertically; 73 private final Drawable mBackground; 74 private OnLongClickListener mOnLongClickListener; 75 private final CheckLongPressHelper mLongPressHelper; 76 private final HolographicOutlineHelper mOutlineHelper; 77 private final StylusEventHelper mStylusEventHelper; 78 79 private boolean mBackgroundSizeChanged; 80 81 private Bitmap mPressedBackground; 82 83 private float mSlop; 84 85 private final boolean mDeferShadowGenerationOnTouch; 86 private final boolean mCustomShadowsEnabled; 87 private final boolean mLayoutHorizontal; 88 private final int mIconSize; 89 @ViewDebug.ExportedProperty(category = "launcher") 90 private int mTextColor; 91 92 @ViewDebug.ExportedProperty(category = "launcher") 93 private boolean mStayPressed; 94 @ViewDebug.ExportedProperty(category = "launcher") 95 private boolean mIgnorePressedStateChange; 96 @ViewDebug.ExportedProperty(category = "launcher") 97 private boolean mDisableRelayout = false; 98 99 private IconLoadRequest mIconLoadRequest; 100 101 public BubbleTextView(Context context) { 102 this(context, null, 0); 103 } 104 105 public BubbleTextView(Context context, AttributeSet attrs) { 106 this(context, attrs, 0); 107 } 108 109 public BubbleTextView(Context context, AttributeSet attrs, int defStyle) { 110 super(context, attrs, defStyle); 111 mLauncher = Launcher.getLauncher(context); 112 DeviceProfile grid = mLauncher.getDeviceProfile(); 113 114 TypedArray a = context.obtainStyledAttributes(attrs, 115 R.styleable.BubbleTextView, defStyle, 0); 116 mCustomShadowsEnabled = a.getBoolean(R.styleable.BubbleTextView_customShadows, true); 117 mLayoutHorizontal = a.getBoolean(R.styleable.BubbleTextView_layoutHorizontal, false); 118 mDeferShadowGenerationOnTouch = 119 a.getBoolean(R.styleable.BubbleTextView_deferShadowGeneration, false); 120 121 int display = a.getInteger(R.styleable.BubbleTextView_iconDisplay, DISPLAY_WORKSPACE); 122 int defaultIconSize = grid.iconSizePx; 123 if (display == DISPLAY_WORKSPACE) { 124 setTextSize(TypedValue.COMPLEX_UNIT_PX, grid.iconTextSizePx); 125 } else if (display == DISPLAY_ALL_APPS) { 126 setTextSize(TypedValue.COMPLEX_UNIT_PX, grid.allAppsIconTextSizePx); 127 setCompoundDrawablePadding(grid.allAppsIconDrawablePaddingPx); 128 defaultIconSize = grid.allAppsIconSizePx; 129 } else if (display == DISPLAY_FOLDER) { 130 setCompoundDrawablePadding(grid.folderChildDrawablePaddingPx); 131 } 132 mCenterVertically = a.getBoolean(R.styleable.BubbleTextView_centerVertically, false); 133 134 mIconSize = a.getDimensionPixelSize(R.styleable.BubbleTextView_iconSizeOverride, 135 defaultIconSize); 136 a.recycle(); 137 138 if (mCustomShadowsEnabled) { 139 // Draw the background itself as the parent is drawn twice. 140 mBackground = getBackground(); 141 setBackground(null); 142 143 // Set shadow layer as the larger shadow to that the textView does not clip the shadow. 144 float density = getResources().getDisplayMetrics().density; 145 setShadowLayer(density * AMBIENT_SHADOW_RADIUS, 0, 0, AMBIENT_SHADOW_COLOR); 146 } else { 147 mBackground = null; 148 } 149 150 mLongPressHelper = new CheckLongPressHelper(this); 151 mStylusEventHelper = new StylusEventHelper(new SimpleOnStylusPressListener(this), this); 152 153 mOutlineHelper = HolographicOutlineHelper.obtain(getContext()); 154 setAccessibilityDelegate(mLauncher.getAccessibilityDelegate()); 155 } 156 157 public void applyFromShortcutInfo(ShortcutInfo info, IconCache iconCache) { 158 applyFromShortcutInfo(info, iconCache, false); 159 } 160 161 public void applyFromShortcutInfo(ShortcutInfo info, IconCache iconCache, 162 boolean promiseStateChanged) { 163 applyIconAndLabel(info.getIcon(iconCache), info); 164 setTag(info); 165 if (promiseStateChanged || info.isPromise()) { 166 applyState(promiseStateChanged); 167 } 168 } 169 170 public void applyFromApplicationInfo(AppInfo info) { 171 applyIconAndLabel(info.iconBitmap, info); 172 173 // We don't need to check the info since it's not a ShortcutInfo 174 super.setTag(info); 175 176 // Verify high res immediately 177 verifyHighRes(); 178 } 179 180 public void applyFromPackageItemInfo(PackageItemInfo info) { 181 applyIconAndLabel(info.iconBitmap, info); 182 // We don't need to check the info since it's not a ShortcutInfo 183 super.setTag(info); 184 185 // Verify high res immediately 186 verifyHighRes(); 187 } 188 189 private void applyIconAndLabel(Bitmap icon, ItemInfo info) { 190 FastBitmapDrawable iconDrawable = mLauncher.createIconDrawable(icon); 191 if (info.isDisabled()) { 192 iconDrawable.setState(FastBitmapDrawable.State.DISABLED); 193 } 194 setIcon(iconDrawable); 195 setText(info.title); 196 if (info.contentDescription != null) { 197 setContentDescription(info.isDisabled() 198 ? getContext().getString(R.string.disabled_app_label, info.contentDescription) 199 : info.contentDescription); 200 } 201 } 202 203 /** 204 * Used for measurement only, sets some dummy values on this view. 205 */ 206 public void applyDummyInfo() { 207 ColorDrawable d = new ColorDrawable(); 208 setIcon(mLauncher.resizeIconDrawable(d)); 209 setText(""); 210 } 211 212 /** 213 * Overrides the default long press timeout. 214 */ 215 public void setLongPressTimeout(int longPressTimeout) { 216 mLongPressHelper.setLongPressTimeout(longPressTimeout); 217 } 218 219 @Override 220 protected boolean setFrame(int left, int top, int right, int bottom) { 221 if (getLeft() != left || getRight() != right || getTop() != top || getBottom() != bottom) { 222 mBackgroundSizeChanged = true; 223 } 224 return super.setFrame(left, top, right, bottom); 225 } 226 227 @Override 228 protected boolean verifyDrawable(Drawable who) { 229 return who == mBackground || super.verifyDrawable(who); 230 } 231 232 @Override 233 public void setTag(Object tag) { 234 if (tag != null) { 235 LauncherModel.checkItemInfo((ItemInfo) tag); 236 } 237 super.setTag(tag); 238 } 239 240 @Override 241 public void setPressed(boolean pressed) { 242 super.setPressed(pressed); 243 244 if (!mIgnorePressedStateChange) { 245 updateIconState(); 246 } 247 } 248 249 /** Returns the icon for this view. */ 250 public Drawable getIcon() { 251 return mIcon; 252 } 253 254 /** Returns whether the layout is horizontal. */ 255 public boolean isLayoutHorizontal() { 256 return mLayoutHorizontal; 257 } 258 259 private void updateIconState() { 260 if (mIcon instanceof FastBitmapDrawable) { 261 FastBitmapDrawable d = (FastBitmapDrawable) mIcon; 262 if (getTag() instanceof ItemInfo 263 && ((ItemInfo) getTag()).isDisabled()) { 264 d.animateState(FastBitmapDrawable.State.DISABLED); 265 } else if (isPressed() || mStayPressed) { 266 d.animateState(FastBitmapDrawable.State.PRESSED); 267 } else { 268 d.animateState(FastBitmapDrawable.State.NORMAL); 269 } 270 } 271 } 272 273 @Override 274 public void setOnLongClickListener(OnLongClickListener l) { 275 super.setOnLongClickListener(l); 276 mOnLongClickListener = l; 277 } 278 279 public OnLongClickListener getOnLongClickListener() { 280 return mOnLongClickListener; 281 } 282 283 @Override 284 public boolean onTouchEvent(MotionEvent event) { 285 // Call the superclass onTouchEvent first, because sometimes it changes the state to 286 // isPressed() on an ACTION_UP 287 boolean result = super.onTouchEvent(event); 288 289 // Check for a stylus button press, if it occurs cancel any long press checks. 290 if (mStylusEventHelper.onMotionEvent(event)) { 291 mLongPressHelper.cancelLongPress(); 292 result = true; 293 } 294 295 switch (event.getAction()) { 296 case MotionEvent.ACTION_DOWN: 297 // So that the pressed outline is visible immediately on setStayPressed(), 298 // we pre-create it on ACTION_DOWN (it takes a small but perceptible amount of time 299 // to create it) 300 if (!mDeferShadowGenerationOnTouch && mPressedBackground == null) { 301 mPressedBackground = mOutlineHelper.createMediumDropShadow(this); 302 } 303 304 // If we're in a stylus button press, don't check for long press. 305 if (!mStylusEventHelper.inStylusButtonPressed()) { 306 mLongPressHelper.postCheckForLongPress(); 307 } 308 break; 309 case MotionEvent.ACTION_CANCEL: 310 case MotionEvent.ACTION_UP: 311 // If we've touched down and up on an item, and it's still not "pressed", then 312 // destroy the pressed outline 313 if (!isPressed()) { 314 mPressedBackground = null; 315 } 316 317 mLongPressHelper.cancelLongPress(); 318 break; 319 case MotionEvent.ACTION_MOVE: 320 if (!Utilities.pointInView(this, event.getX(), event.getY(), mSlop)) { 321 mLongPressHelper.cancelLongPress(); 322 } 323 break; 324 } 325 return result; 326 } 327 328 void setStayPressed(boolean stayPressed) { 329 mStayPressed = stayPressed; 330 if (!stayPressed) { 331 HolographicOutlineHelper.obtain(getContext()).recycleShadowBitmap(mPressedBackground); 332 mPressedBackground = null; 333 } else { 334 if (mPressedBackground == null) { 335 mPressedBackground = mOutlineHelper.createMediumDropShadow(this); 336 } 337 } 338 339 // Only show the shadow effect when persistent pressed state is set. 340 ViewParent parent = getParent(); 341 if (parent != null && parent.getParent() instanceof BubbleTextShadowHandler) { 342 ((BubbleTextShadowHandler) parent.getParent()).setPressedIcon( 343 this, mPressedBackground); 344 } 345 346 updateIconState(); 347 } 348 349 void clearPressedBackground() { 350 setPressed(false); 351 setStayPressed(false); 352 } 353 354 @Override 355 public boolean onKeyDown(int keyCode, KeyEvent event) { 356 if (super.onKeyDown(keyCode, event)) { 357 // Pre-create shadow so show immediately on click. 358 if (mPressedBackground == null) { 359 mPressedBackground = mOutlineHelper.createMediumDropShadow(this); 360 } 361 return true; 362 } 363 return false; 364 } 365 366 @Override 367 public boolean onKeyUp(int keyCode, KeyEvent event) { 368 // Unlike touch events, keypress event propagate pressed state change immediately, 369 // without waiting for onClickHandler to execute. Disable pressed state changes here 370 // to avoid flickering. 371 mIgnorePressedStateChange = true; 372 boolean result = super.onKeyUp(keyCode, event); 373 374 mPressedBackground = null; 375 mIgnorePressedStateChange = false; 376 updateIconState(); 377 return result; 378 } 379 380 @Override 381 public void draw(Canvas canvas) { 382 if (!mCustomShadowsEnabled) { 383 super.draw(canvas); 384 return; 385 } 386 387 final Drawable background = mBackground; 388 if (background != null) { 389 final int scrollX = getScrollX(); 390 final int scrollY = getScrollY(); 391 392 if (mBackgroundSizeChanged) { 393 background.setBounds(0, 0, getRight() - getLeft(), getBottom() - getTop()); 394 mBackgroundSizeChanged = false; 395 } 396 397 if ((scrollX | scrollY) == 0) { 398 background.draw(canvas); 399 } else { 400 canvas.translate(scrollX, scrollY); 401 background.draw(canvas); 402 canvas.translate(-scrollX, -scrollY); 403 } 404 } 405 406 // If text is transparent, don't draw any shadow 407 if (getCurrentTextColor() == getResources().getColor(android.R.color.transparent)) { 408 getPaint().clearShadowLayer(); 409 super.draw(canvas); 410 return; 411 } 412 413 // We enhance the shadow by drawing the shadow twice 414 float density = getResources().getDisplayMetrics().density; 415 getPaint().setShadowLayer(density * AMBIENT_SHADOW_RADIUS, 0, 0, AMBIENT_SHADOW_COLOR); 416 super.draw(canvas); 417 canvas.save(Canvas.CLIP_SAVE_FLAG); 418 canvas.clipRect(getScrollX(), getScrollY() + getExtendedPaddingTop(), 419 getScrollX() + getWidth(), 420 getScrollY() + getHeight(), Region.Op.INTERSECT); 421 getPaint().setShadowLayer( 422 density * KEY_SHADOW_RADIUS, 0.0f, density * KEY_SHADOW_OFFSET, KEY_SHADOW_COLOR); 423 super.draw(canvas); 424 canvas.restore(); 425 } 426 427 @Override 428 protected void onAttachedToWindow() { 429 super.onAttachedToWindow(); 430 431 if (mBackground != null) mBackground.setCallback(this); 432 433 if (mIcon instanceof PreloadIconDrawable) { 434 ((PreloadIconDrawable) mIcon).applyPreloaderTheme(getPreloaderTheme()); 435 } 436 mSlop = ViewConfiguration.get(getContext()).getScaledTouchSlop(); 437 } 438 439 @Override 440 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 441 if (mCenterVertically) { 442 Paint.FontMetrics fm = getPaint().getFontMetrics(); 443 int cellHeightPx = mIconSize + getCompoundDrawablePadding() + 444 (int) Math.ceil(fm.bottom - fm.top); 445 int height = MeasureSpec.getSize(heightMeasureSpec); 446 setPadding(getPaddingLeft(), (height - cellHeightPx) / 2, getPaddingRight(), 447 getPaddingBottom()); 448 } 449 super.onMeasure(widthMeasureSpec, heightMeasureSpec); 450 } 451 452 @Override 453 protected void onDetachedFromWindow() { 454 super.onDetachedFromWindow(); 455 if (mBackground != null) mBackground.setCallback(null); 456 } 457 458 @Override 459 public void setTextColor(int color) { 460 mTextColor = color; 461 super.setTextColor(color); 462 } 463 464 @Override 465 public void setTextColor(ColorStateList colors) { 466 mTextColor = colors.getDefaultColor(); 467 super.setTextColor(colors); 468 } 469 470 public void setTextVisibility(boolean visible) { 471 Resources res = getResources(); 472 if (visible) { 473 super.setTextColor(mTextColor); 474 } else { 475 super.setTextColor(res.getColor(android.R.color.transparent)); 476 } 477 } 478 479 @Override 480 public void cancelLongPress() { 481 super.cancelLongPress(); 482 483 mLongPressHelper.cancelLongPress(); 484 } 485 486 public void applyState(boolean promiseStateChanged) { 487 if (getTag() instanceof ShortcutInfo) { 488 ShortcutInfo info = (ShortcutInfo) getTag(); 489 final boolean isPromise = info.isPromise(); 490 final int progressLevel = isPromise ? 491 ((info.hasStatusFlag(ShortcutInfo.FLAG_INSTALL_SESSION_ACTIVE) ? 492 info.getInstallProgress() : 0)) : 100; 493 494 setContentDescription(progressLevel > 0 ? 495 getContext().getString(R.string.app_downloading_title, info.title, 496 NumberFormat.getPercentInstance().format(progressLevel * 0.01)) : 497 getContext().getString(R.string.app_waiting_download_title, info.title)); 498 499 if (mIcon != null) { 500 final PreloadIconDrawable preloadDrawable; 501 if (mIcon instanceof PreloadIconDrawable) { 502 preloadDrawable = (PreloadIconDrawable) mIcon; 503 } else { 504 preloadDrawable = new PreloadIconDrawable(mIcon, getPreloaderTheme()); 505 setIcon(preloadDrawable); 506 } 507 508 preloadDrawable.setLevel(progressLevel); 509 if (promiseStateChanged) { 510 preloadDrawable.maybePerformFinishedAnimation(); 511 } 512 } 513 } 514 } 515 516 private Theme getPreloaderTheme() { 517 Object tag = getTag(); 518 int style = ((tag != null) && (tag instanceof ShortcutInfo) && 519 (((ShortcutInfo) tag).container >= 0)) ? R.style.PreloadIcon_Folder 520 : R.style.PreloadIcon; 521 Theme theme = sPreloaderThemes.get(style); 522 if (theme == null) { 523 theme = getResources().newTheme(); 524 theme.applyStyle(style, true); 525 sPreloaderThemes.put(style, theme); 526 } 527 return theme; 528 } 529 530 /** 531 * Sets the icon for this view based on the layout direction. 532 */ 533 @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1) 534 private void setIcon(Drawable icon) { 535 mIcon = icon; 536 if (mIconSize != -1) { 537 mIcon.setBounds(0, 0, mIconSize, mIconSize); 538 } 539 applyCompoundDrawables(mIcon); 540 } 541 542 protected void applyCompoundDrawables(Drawable icon) { 543 if (mLayoutHorizontal) { 544 if (Utilities.ATLEAST_JB_MR1) { 545 setCompoundDrawablesRelative(icon, null, null, null); 546 } else { 547 setCompoundDrawables(icon, null, null, null); 548 } 549 } else { 550 setCompoundDrawables(null, icon, null, null); 551 } 552 } 553 554 @Override 555 public void requestLayout() { 556 if (!mDisableRelayout) { 557 super.requestLayout(); 558 } 559 } 560 561 /** 562 * Applies the item info if it is same as what the view is pointing to currently. 563 */ 564 public void reapplyItemInfo(final ItemInfo info) { 565 if (getTag() == info) { 566 FastBitmapDrawable.State prevState = FastBitmapDrawable.State.NORMAL; 567 if (mIcon instanceof FastBitmapDrawable) { 568 prevState = ((FastBitmapDrawable) mIcon).getCurrentState(); 569 } 570 mIconLoadRequest = null; 571 mDisableRelayout = true; 572 573 if (info instanceof AppInfo) { 574 applyFromApplicationInfo((AppInfo) info); 575 } else if (info instanceof ShortcutInfo) { 576 applyFromShortcutInfo((ShortcutInfo) info, 577 LauncherAppState.getInstance().getIconCache()); 578 if ((info.rank < FolderIcon.NUM_ITEMS_IN_PREVIEW) && (info.container >= 0)) { 579 View folderIcon = 580 mLauncher.getWorkspace().getHomescreenIconByItemId(info.container); 581 if (folderIcon != null) { 582 folderIcon.invalidate(); 583 } 584 } 585 } else if (info instanceof PackageItemInfo) { 586 applyFromPackageItemInfo((PackageItemInfo) info); 587 } 588 589 // If we are reapplying over an old icon, then we should update the new icon to the same 590 // state as the old icon 591 if (mIcon instanceof FastBitmapDrawable) { 592 ((FastBitmapDrawable) mIcon).setState(prevState); 593 } 594 595 mDisableRelayout = false; 596 } 597 } 598 599 /** 600 * Verifies that the current icon is high-res otherwise posts a request to load the icon. 601 */ 602 public void verifyHighRes() { 603 if (mIconLoadRequest != null) { 604 mIconLoadRequest.cancel(); 605 mIconLoadRequest = null; 606 } 607 if (getTag() instanceof AppInfo) { 608 AppInfo info = (AppInfo) getTag(); 609 if (info.usingLowResIcon) { 610 mIconLoadRequest = LauncherAppState.getInstance().getIconCache() 611 .updateIconInBackground(BubbleTextView.this, info); 612 } 613 } else if (getTag() instanceof ShortcutInfo) { 614 ShortcutInfo info = (ShortcutInfo) getTag(); 615 if (info.usingLowResIcon) { 616 mIconLoadRequest = LauncherAppState.getInstance().getIconCache() 617 .updateIconInBackground(BubbleTextView.this, info); 618 } 619 } else if (getTag() instanceof PackageItemInfo) { 620 PackageItemInfo info = (PackageItemInfo) getTag(); 621 if (info.usingLowResIcon) { 622 mIconLoadRequest = LauncherAppState.getInstance().getIconCache() 623 .updateIconInBackground(BubbleTextView.this, info); 624 } 625 } 626 } 627 628 @Override 629 public void setFastScrollFocusState(final FastBitmapDrawable.State focusState, boolean animated) { 630 // We can only set the fast scroll focus state on a FastBitmapDrawable 631 if (!(mIcon instanceof FastBitmapDrawable)) { 632 return; 633 } 634 635 FastBitmapDrawable d = (FastBitmapDrawable) mIcon; 636 if (animated) { 637 FastBitmapDrawable.State prevState = d.getCurrentState(); 638 if (d.animateState(focusState)) { 639 // If the state was updated, then update the view accordingly 640 animate().scaleX(focusState.viewScale) 641 .scaleY(focusState.viewScale) 642 .setStartDelay(getStartDelayForStateChange(prevState, focusState)) 643 .setDuration(d.getDurationForStateChange(prevState, focusState)) 644 .start(); 645 } 646 } else { 647 if (d.setState(focusState)) { 648 // If the state was updated, then update the view accordingly 649 animate().cancel(); 650 setScaleX(focusState.viewScale); 651 setScaleY(focusState.viewScale); 652 } 653 } 654 } 655 656 /** 657 * Returns true if the view can show custom shortcuts. 658 */ 659 public boolean hasDeepShortcuts() { 660 return !mLauncher.getShortcutIdsForItem((ItemInfo) getTag()).isEmpty(); 661 } 662 663 /** 664 * Returns the start delay when animating between certain {@link FastBitmapDrawable} states. 665 */ 666 private static int getStartDelayForStateChange(final FastBitmapDrawable.State fromState, 667 final FastBitmapDrawable.State toState) { 668 switch (toState) { 669 case NORMAL: 670 switch (fromState) { 671 case FAST_SCROLL_HIGHLIGHTED: 672 return FastBitmapDrawable.FAST_SCROLL_INACTIVE_DURATION / 4; 673 } 674 } 675 return 0; 676 } 677 678 /** 679 * Interface to be implemented by the grand parent to allow click shadow effect. 680 */ 681 public interface BubbleTextShadowHandler { 682 void setPressedIcon(BubbleTextView icon, Bitmap background); 683 } 684 } 685