src/com/android/launcher3/allapps/RecyclerViewAnimationController.java - LeafOS-Project/android_packages_apps_Launcher3 - Gitiles

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

 import static androidx.recyclerview.widget.RecyclerView.NO_POSITION;

 import static com.android.app.animation.Interpolators.DECELERATE_1_7;
 import static com.android.app.animation.Interpolators.INSTANT;
 import static com.android.app.animation.Interpolators.clampToProgress;
 import static com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_APPLICATION;
 import static com.android.launcher3.anim.AnimatorListeners.forEndCallback;
 import static com.android.launcher3.anim.AnimatorListeners.forSuccessCallback;

 import android.animation.ObjectAnimator;
 import android.animation.TimeInterpolator;
 import android.graphics.drawable.Drawable;
 import android.util.FloatProperty;
 import android.util.Log;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.animation.Interpolator;

 import com.android.launcher3.BubbleTextView;
 import com.android.launcher3.Utilities;
 import com.android.launcher3.model.data.ItemInfo;

 import java.util.List;

 public class RecyclerViewAnimationController {

     private static final String LOG_TAG = "AnimationCtrl";

     /**
      * These values represent points on the [0, 1] animation progress spectrum. They are used to
      * animate items in the {@link SearchRecyclerView} and private space container in
      * {@link AllAppsRecyclerView}.
      */
     protected static final float TOP_CONTENT_FADE_PROGRESS_START = 0.133f;
     protected static final float CONTENT_FADE_PROGRESS_DURATION = 0.083f;
     protected static final float TOP_BACKGROUND_FADE_PROGRESS_START = 0.633f;
     protected static final float BACKGROUND_FADE_PROGRESS_DURATION = 0.15f;
     // Progress before next item starts fading.
     protected static final float CONTENT_STAGGER = 0.01f;

     protected static final FloatProperty<RecyclerViewAnimationController> PROGRESS =
             new FloatProperty<RecyclerViewAnimationController>("expansionProgress") {
                 @Override
                 public Float get(RecyclerViewAnimationController controller) {
                     return controller.getAnimationProgress();
                 }

                 @Override
                 public void setValue(RecyclerViewAnimationController controller, float progress) {
                     controller.setAnimationProgress(progress);
                 }
             };

     protected final ActivityAllAppsContainerView<?> mAllAppsContainerView;
     protected ObjectAnimator mAnimator = null;
     private float mAnimatorProgress = 1f;

     public RecyclerViewAnimationController(ActivityAllAppsContainerView<?> allAppsContainerView) {
         mAllAppsContainerView = allAppsContainerView;
     }

     /**
      * Updates the children views of the current recyclerView based on the current animation
      * progress.
      *
      * @return the total height of animating views (may exclude at most one row of app icons
      * depending on which recyclerView is being acted upon).
      */
     protected int onProgressUpdated(float expansionProgress) {
         int numItemsAnimated = 0;
         int totalHeight = 0;
         int appRowHeight = 0;
         boolean appRowComplete = false;
         Integer top = null;
         AllAppsRecyclerView allAppsRecyclerView = getRecyclerView();

         for (int i = 0; i < allAppsRecyclerView.getChildCount(); i++) {
             View currentView = allAppsRecyclerView.getChildAt(i);
             if (currentView == null) {
                 continue;
             }
             if (top == null) {
                 top = currentView.getTop();
             }
             int adapterPosition = allAppsRecyclerView.getChildAdapterPosition(currentView);
             List<BaseAllAppsAdapter.AdapterItem> allAppsAdapters = allAppsRecyclerView.getApps()
                     .getAdapterItems();
             if (adapterPosition < 0 || adapterPosition >= allAppsAdapters.size()) {
                 continue;
             }
             BaseAllAppsAdapter.AdapterItem adapterItemAtPosition =
                     allAppsAdapters.get(adapterPosition);
             int spanIndex = getSpanIndex(allAppsRecyclerView, adapterPosition);
             appRowComplete |= appRowHeight > 0 && spanIndex == 0;

             float backgroundAlpha = 1f;
             boolean hasDecorationInfo = adapterItemAtPosition.getDecorationInfo() != null;
             boolean shouldAnimate = shouldAnimate(currentView, hasDecorationInfo, appRowComplete);

             if (shouldAnimate) {
                 if (spanIndex > 0) {
                     // Animate this item with the previous item on the same row.
                     numItemsAnimated--;
                 }
                 // Adjust background (or decorator) alpha based on start progress and stagger.
                 backgroundAlpha = getAdjustedBackgroundAlpha(numItemsAnimated);
             }

             Drawable background = currentView.getBackground();
             if (background != null && currentView instanceof ViewGroup currentViewGroup) {
                 currentView.setAlpha(1f);
                 // Apply content alpha to each child, since the view needs to be fully opaque for
                 // the background to show properly.
                 for (int j = 0; j < currentViewGroup.getChildCount(); j++) {
                     setViewAdjustedContentAlpha(currentViewGroup.getChildAt(j), numItemsAnimated,
                             shouldAnimate);
                 }

                 // Apply background alpha to the background drawable directly.
                 background.setAlpha((int) (255 * backgroundAlpha));
             } else {
                 // Adjust content alpha based on start progress and stagger.
                 setViewAdjustedContentAlpha(currentView, numItemsAnimated, shouldAnimate);

                 // Apply background alpha to decorator if possible.
                 setAdjustedAdapterItemDecorationBackgroundAlpha(
                         allAppsRecyclerView.getApps().getAdapterItems().get(adapterPosition),
                         numItemsAnimated);

                 // Apply background alpha to view's background (e.g. for Search Edu card).
                 if (background != null) {
                     background.setAlpha((int) (255 * backgroundAlpha));
                 }
             }

             float scaleY = 1;
             if (shouldAnimate) {
                 scaleY = 1 - getAnimationProgress();
                 // Update number of search results that has been animated.
                 numItemsAnimated++;
             }
             int scaledHeight = (int) (currentView.getHeight() * scaleY);
             currentView.setScaleY(scaleY);

             // For rows with multiple elements, only count the height once and translate elements to
             // the same y position.
             int y = top + totalHeight;
             if (spanIndex > 0) {
                 // Continuation of an existing row; move this item into the row.
                 y -= scaledHeight;
             } else {
                 // Start of a new row contributes to total height.
                 totalHeight += scaledHeight;
                 if (!shouldAnimate) {
                     appRowHeight = scaledHeight;
                 }
             }
             currentView.setY(y);
         }
         return totalHeight - appRowHeight;
     }

     protected void animateToState(boolean expand, long duration, Runnable onEndRunnable) {
         float targetProgress = expand ? 0 : 1;
         if (mAnimator != null) {
             mAnimator.cancel();
         }
         mAnimator = ObjectAnimator.ofFloat(this, PROGRESS, targetProgress);

         TimeInterpolator timeInterpolator = getInterpolator();
         if (timeInterpolator == INSTANT) {
             duration = 0;
         }

         mAnimator.addListener(forEndCallback(() -> mAnimator = null));
         mAnimator.setDuration(duration).setInterpolator(timeInterpolator);
         mAnimator.addListener(forSuccessCallback(onEndRunnable));
         mAnimator.start();
         getRecyclerView().setChildAttachedConsumer(this::onChildAttached);
     }

     /** Called just before a child is attached to the RecyclerView. */
     private void onChildAttached(View child) {
         // Avoid allocating hardware layers for alpha changes.
         child.forceHasOverlappingRendering(false);
         child.setPivotY(0);
         if (getAnimationProgress() > 0 && getAnimationProgress() < 1) {
             // Before the child is rendered, apply the animation including it to avoid flicker.
             onProgressUpdated(getAnimationProgress());
         } else {
             // Apply default states without processing the full layout.
             child.setAlpha(1);
             child.setScaleY(1);
             child.setTranslationY(0);
             int adapterPosition = getRecyclerView().getChildAdapterPosition(child);
             List<BaseAllAppsAdapter.AdapterItem> allAppsAdapters =
                     getRecyclerView().getApps().getAdapterItems();
             if (adapterPosition >= 0 && adapterPosition < allAppsAdapters.size()) {
                 allAppsAdapters.get(adapterPosition).setDecorationFillAlpha(255);
             }
             if (child instanceof ViewGroup childGroup) {
                 for (int i = 0; i < childGroup.getChildCount(); i++) {
                     childGroup.getChildAt(i).setAlpha(1f);
                 }
             }
             if (child.getBackground() != null) {
                 child.getBackground().setAlpha(255);
             }
         }
     }

     /** @return the column that the view at this position is found (0 assumed if indeterminate). */
     protected int getSpanIndex(AllAppsRecyclerView appsRecyclerView, int adapterPosition) {
         if (adapterPosition == NO_POSITION) {
             Log.w(LOG_TAG, "Can't determine span index - child not found in adapter");
             return 0;
         }
         if (!(appsRecyclerView.getAdapter() instanceof AllAppsGridAdapter<?>)) {
             Log.e(LOG_TAG, "Search RV doesn't have an AllAppsGridAdapter?");
             // This case shouldn't happen, but for debug devices we will continue to create a more
             // visible crash.
             if (!Utilities.IS_DEBUG_DEVICE) {
                 return 0;
             }
         }
         AllAppsGridAdapter<?> adapter = (AllAppsGridAdapter<?>) appsRecyclerView.getAdapter();
         return adapter.getSpanIndex(adapterPosition);
     }

     protected TimeInterpolator getInterpolator() {
         return DECELERATE_1_7;
     }

     protected AllAppsRecyclerView getRecyclerView() {
         return mAllAppsContainerView.mAH.get(ActivityAllAppsContainerView.AdapterHolder.MAIN)
                 .mRecyclerView;
     }

     /** Returns true if a transition animation is currently in progress. */
     protected boolean isRunning() {
         return mAnimator != null;
     }

     /** Should only animate if the view is an app icon and if it has a decoration info. */
     protected boolean shouldAnimate(View view, boolean hasDecorationInfo,
             boolean firstAppRowComplete) {
         return isAppIcon(view) && hasDecorationInfo;
     }

     private float getAdjustedContentAlpha(int itemsAnimated) {
         float startContentFadeProgress = Math.max(0,
                 TOP_CONTENT_FADE_PROGRESS_START - CONTENT_STAGGER * itemsAnimated);
         float endContentFadeProgress = Math.min(1,
                 startContentFadeProgress + CONTENT_FADE_PROGRESS_DURATION);
         return 1 - clampToProgress(mAnimatorProgress,
                 startContentFadeProgress, endContentFadeProgress);
     }

     private float getAdjustedBackgroundAlpha(int itemsAnimated) {
         float startBackgroundFadeProgress = Math.max(0,
                 TOP_BACKGROUND_FADE_PROGRESS_START - CONTENT_STAGGER * itemsAnimated);
         float endBackgroundFadeProgress = Math.min(1,
                 startBackgroundFadeProgress + BACKGROUND_FADE_PROGRESS_DURATION);
         return 1 - clampToProgress(mAnimatorProgress,
                 startBackgroundFadeProgress, endBackgroundFadeProgress);
     }

     private void setViewAdjustedContentAlpha(View view, int numberOfItemsAnimated,
             boolean shouldAnimate) {
         view.setAlpha(shouldAnimate ? getAdjustedContentAlpha(numberOfItemsAnimated) : 1f);
     }

     private void setAdjustedAdapterItemDecorationBackgroundAlpha(
             BaseAllAppsAdapter.AdapterItem adapterItem, int numberOfItemsAnimated) {
         adapterItem.setDecorationFillAlpha((int)
                 (255 * getAdjustedBackgroundAlpha(numberOfItemsAnimated)));
     }

     private float getAnimationProgress() {
         return mAnimatorProgress;
     }

     private void setAnimationProgress(float expansionProgress) {
         mAnimatorProgress = expansionProgress;
         onProgressUpdated(expansionProgress);
     }

     protected boolean isAppIcon(View item) {
         return item instanceof BubbleTextView && item.getTag() instanceof ItemInfo
                 && ((ItemInfo) item.getTag()).itemType == ITEM_TYPE_APPLICATION;
     }
 }
	/*
	* Copyright (C) 2023 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.allapps;

	import static androidx.recyclerview.widget.RecyclerView.NO_POSITION;

	import static com.android.app.animation.Interpolators.DECELERATE_1_7;
	import static com.android.app.animation.Interpolators.INSTANT;
	import static com.android.app.animation.Interpolators.clampToProgress;
	import static com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_APPLICATION;
	import static com.android.launcher3.anim.AnimatorListeners.forEndCallback;
	import static com.android.launcher3.anim.AnimatorListeners.forSuccessCallback;

	import android.animation.ObjectAnimator;
	import android.animation.TimeInterpolator;
	import android.graphics.drawable.Drawable;
	import android.util.FloatProperty;
	import android.util.Log;
	import android.view.View;
	import android.view.ViewGroup;
	import android.view.animation.Interpolator;

	import com.android.launcher3.BubbleTextView;
	import com.android.launcher3.Utilities;
	import com.android.launcher3.model.data.ItemInfo;

	import java.util.List;

	public class RecyclerViewAnimationController {

	private static final String LOG_TAG = "AnimationCtrl";

	/**
	* These values represent points on the [0, 1] animation progress spectrum. They are used to
	* animate items in the {@link SearchRecyclerView} and private space container in
	* {@link AllAppsRecyclerView}.
	*/
	protected static final float TOP_CONTENT_FADE_PROGRESS_START = 0.133f;
	protected static final float CONTENT_FADE_PROGRESS_DURATION = 0.083f;
	protected static final float TOP_BACKGROUND_FADE_PROGRESS_START = 0.633f;
	protected static final float BACKGROUND_FADE_PROGRESS_DURATION = 0.15f;
	// Progress before next item starts fading.
	protected static final float CONTENT_STAGGER = 0.01f;

	protected static final FloatProperty<RecyclerViewAnimationController> PROGRESS =
	new FloatProperty<RecyclerViewAnimationController>("expansionProgress") {
	@Override
	public Float get(RecyclerViewAnimationController controller) {
	return controller.getAnimationProgress();
	}

	@Override
	public void setValue(RecyclerViewAnimationController controller, float progress) {
	controller.setAnimationProgress(progress);
	}
	};

	protected final ActivityAllAppsContainerView<?> mAllAppsContainerView;
	protected ObjectAnimator mAnimator = null;
	private float mAnimatorProgress = 1f;

	public RecyclerViewAnimationController(ActivityAllAppsContainerView<?> allAppsContainerView) {
	mAllAppsContainerView = allAppsContainerView;
	}

	/**
	* Updates the children views of the current recyclerView based on the current animation
	* progress.
	*
	* @return the total height of animating views (may exclude at most one row of app icons
	* depending on which recyclerView is being acted upon).
	*/
	protected int onProgressUpdated(float expansionProgress) {
	int numItemsAnimated = 0;
	int totalHeight = 0;
	int appRowHeight = 0;
	boolean appRowComplete = false;
	Integer top = null;
	AllAppsRecyclerView allAppsRecyclerView = getRecyclerView();

	for (int i = 0; i < allAppsRecyclerView.getChildCount(); i++) {
	View currentView = allAppsRecyclerView.getChildAt(i);
	if (currentView == null) {
	continue;
	}
	if (top == null) {
	top = currentView.getTop();
	}
	int adapterPosition = allAppsRecyclerView.getChildAdapterPosition(currentView);
	List<BaseAllAppsAdapter.AdapterItem> allAppsAdapters = allAppsRecyclerView.getApps()
	.getAdapterItems();
	if (adapterPosition < 0 \|\| adapterPosition >= allAppsAdapters.size()) {
	continue;
	}
	BaseAllAppsAdapter.AdapterItem adapterItemAtPosition =
	allAppsAdapters.get(adapterPosition);
	int spanIndex = getSpanIndex(allAppsRecyclerView, adapterPosition);
	appRowComplete \|= appRowHeight > 0 && spanIndex == 0;

	float backgroundAlpha = 1f;
	boolean hasDecorationInfo = adapterItemAtPosition.getDecorationInfo() != null;
	boolean shouldAnimate = shouldAnimate(currentView, hasDecorationInfo, appRowComplete);

	if (shouldAnimate) {
	if (spanIndex > 0) {
	// Animate this item with the previous item on the same row.
	numItemsAnimated--;
	}
	// Adjust background (or decorator) alpha based on start progress and stagger.
	backgroundAlpha = getAdjustedBackgroundAlpha(numItemsAnimated);
	}

	Drawable background = currentView.getBackground();
	if (background != null && currentView instanceof ViewGroup currentViewGroup) {
	currentView.setAlpha(1f);
	// Apply content alpha to each child, since the view needs to be fully opaque for
	// the background to show properly.
	for (int j = 0; j < currentViewGroup.getChildCount(); j++) {
	setViewAdjustedContentAlpha(currentViewGroup.getChildAt(j), numItemsAnimated,
	shouldAnimate);
	}

	// Apply background alpha to the background drawable directly.
	background.setAlpha((int) (255 * backgroundAlpha));
	} else {
	// Adjust content alpha based on start progress and stagger.
	setViewAdjustedContentAlpha(currentView, numItemsAnimated, shouldAnimate);

	// Apply background alpha to decorator if possible.
	setAdjustedAdapterItemDecorationBackgroundAlpha(
	allAppsRecyclerView.getApps().getAdapterItems().get(adapterPosition),
	numItemsAnimated);

	// Apply background alpha to view's background (e.g. for Search Edu card).
	if (background != null) {
	background.setAlpha((int) (255 * backgroundAlpha));
	}
	}

	float scaleY = 1;
	if (shouldAnimate) {
	scaleY = 1 - getAnimationProgress();
	// Update number of search results that has been animated.
	numItemsAnimated++;
	}
	int scaledHeight = (int) (currentView.getHeight() * scaleY);
	currentView.setScaleY(scaleY);

	// For rows with multiple elements, only count the height once and translate elements to
	// the same y position.
	int y = top + totalHeight;
	if (spanIndex > 0) {
	// Continuation of an existing row; move this item into the row.
	y -= scaledHeight;
	} else {
	// Start of a new row contributes to total height.
	totalHeight += scaledHeight;
	if (!shouldAnimate) {
	appRowHeight = scaledHeight;
	}
	}
	currentView.setY(y);
	}
	return totalHeight - appRowHeight;
	}

	protected void animateToState(boolean expand, long duration, Runnable onEndRunnable) {
	float targetProgress = expand ? 0 : 1;
	if (mAnimator != null) {
	mAnimator.cancel();
	}
	mAnimator = ObjectAnimator.ofFloat(this, PROGRESS, targetProgress);

	TimeInterpolator timeInterpolator = getInterpolator();
	if (timeInterpolator == INSTANT) {
	duration = 0;
	}

	mAnimator.addListener(forEndCallback(() -> mAnimator = null));
	mAnimator.setDuration(duration).setInterpolator(timeInterpolator);
	mAnimator.addListener(forSuccessCallback(onEndRunnable));
	mAnimator.start();
	getRecyclerView().setChildAttachedConsumer(this::onChildAttached);
	}

	/** Called just before a child is attached to the RecyclerView. */
	private void onChildAttached(View child) {
	// Avoid allocating hardware layers for alpha changes.
	child.forceHasOverlappingRendering(false);
	child.setPivotY(0);
	if (getAnimationProgress() > 0 && getAnimationProgress() < 1) {
	// Before the child is rendered, apply the animation including it to avoid flicker.
	onProgressUpdated(getAnimationProgress());
	} else {
	// Apply default states without processing the full layout.
	child.setAlpha(1);
	child.setScaleY(1);
	child.setTranslationY(0);
	int adapterPosition = getRecyclerView().getChildAdapterPosition(child);
	List<BaseAllAppsAdapter.AdapterItem> allAppsAdapters =
	getRecyclerView().getApps().getAdapterItems();
	if (adapterPosition >= 0 && adapterPosition < allAppsAdapters.size()) {
	allAppsAdapters.get(adapterPosition).setDecorationFillAlpha(255);
	}
	if (child instanceof ViewGroup childGroup) {
	for (int i = 0; i < childGroup.getChildCount(); i++) {
	childGroup.getChildAt(i).setAlpha(1f);
	}
	}
	if (child.getBackground() != null) {
	child.getBackground().setAlpha(255);
	}
	}
	}

	/** @return the column that the view at this position is found (0 assumed if indeterminate). */
	protected int getSpanIndex(AllAppsRecyclerView appsRecyclerView, int adapterPosition) {
	if (adapterPosition == NO_POSITION) {
	Log.w(LOG_TAG, "Can't determine span index - child not found in adapter");
	return 0;
	}
	if (!(appsRecyclerView.getAdapter() instanceof AllAppsGridAdapter<?>)) {
	Log.e(LOG_TAG, "Search RV doesn't have an AllAppsGridAdapter?");
	// This case shouldn't happen, but for debug devices we will continue to create a more
	// visible crash.
	if (!Utilities.IS_DEBUG_DEVICE) {
	return 0;
	}
	}
	AllAppsGridAdapter<?> adapter = (AllAppsGridAdapter<?>) appsRecyclerView.getAdapter();
	return adapter.getSpanIndex(adapterPosition);
	}

	protected TimeInterpolator getInterpolator() {
	return DECELERATE_1_7;
	}

	protected AllAppsRecyclerView getRecyclerView() {
	return mAllAppsContainerView.mAH.get(ActivityAllAppsContainerView.AdapterHolder.MAIN)
	.mRecyclerView;
	}

	/** Returns true if a transition animation is currently in progress. */
	protected boolean isRunning() {
	return mAnimator != null;
	}

	/** Should only animate if the view is an app icon and if it has a decoration info. */
	protected boolean shouldAnimate(View view, boolean hasDecorationInfo,
	boolean firstAppRowComplete) {
	return isAppIcon(view) && hasDecorationInfo;
	}

	private float getAdjustedContentAlpha(int itemsAnimated) {
	float startContentFadeProgress = Math.max(0,
	TOP_CONTENT_FADE_PROGRESS_START - CONTENT_STAGGER * itemsAnimated);
	float endContentFadeProgress = Math.min(1,
	startContentFadeProgress + CONTENT_FADE_PROGRESS_DURATION);
	return 1 - clampToProgress(mAnimatorProgress,
	startContentFadeProgress, endContentFadeProgress);
	}

	private float getAdjustedBackgroundAlpha(int itemsAnimated) {
	float startBackgroundFadeProgress = Math.max(0,
	TOP_BACKGROUND_FADE_PROGRESS_START - CONTENT_STAGGER * itemsAnimated);
	float endBackgroundFadeProgress = Math.min(1,
	startBackgroundFadeProgress + BACKGROUND_FADE_PROGRESS_DURATION);
	return 1 - clampToProgress(mAnimatorProgress,
	startBackgroundFadeProgress, endBackgroundFadeProgress);
	}

	private void setViewAdjustedContentAlpha(View view, int numberOfItemsAnimated,
	boolean shouldAnimate) {
	view.setAlpha(shouldAnimate ? getAdjustedContentAlpha(numberOfItemsAnimated) : 1f);
	}

	private void setAdjustedAdapterItemDecorationBackgroundAlpha(
	BaseAllAppsAdapter.AdapterItem adapterItem, int numberOfItemsAnimated) {
	adapterItem.setDecorationFillAlpha((int)
	(255 * getAdjustedBackgroundAlpha(numberOfItemsAnimated)));
	}

	private float getAnimationProgress() {
	return mAnimatorProgress;
	}

	private void setAnimationProgress(float expansionProgress) {
	mAnimatorProgress = expansionProgress;
	onProgressUpdated(expansionProgress);
	}

	protected boolean isAppIcon(View item) {
	return item instanceof BubbleTextView && item.getTag() instanceof ItemInfo
	&& ((ItemInfo) item.getTag()).itemType == ITEM_TYPE_APPLICATION;
	}
	}