Workspace.java revision dfab7f0285eea71abd7fa64e893541fdf831c73b
1/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.launcher2;
18
19import android.animation.Animator;
20import android.animation.Animator.AnimatorListener;
21import android.animation.AnimatorListenerAdapter;
22import android.animation.AnimatorSet;
23import android.animation.ObjectAnimator;
24import android.animation.TimeInterpolator;
25import android.animation.ValueAnimator;
26import android.animation.ValueAnimator.AnimatorUpdateListener;
27import android.app.AlertDialog;
28import android.app.WallpaperManager;
29import android.appwidget.AppWidgetHostView;
30import android.appwidget.AppWidgetManager;
31import android.appwidget.AppWidgetProviderInfo;
32import android.content.ClipData;
33import android.content.ClipDescription;
34import android.content.ComponentName;
35import android.content.Context;
36import android.content.Intent;
37import android.content.res.Resources;
38import android.content.res.TypedArray;
39import android.graphics.Bitmap;
40import android.graphics.Camera;
41import android.graphics.Canvas;
42import android.graphics.Matrix;
43import android.graphics.Paint;
44import android.graphics.Point;
45import android.graphics.PorterDuff;
46import android.graphics.Rect;
47import android.graphics.RectF;
48import android.graphics.Region.Op;
49import android.graphics.drawable.Drawable;
50import android.os.IBinder;
51import android.os.Parcelable;
52import android.util.AttributeSet;
53import android.util.DisplayMetrics;
54import android.util.Log;
55import android.util.Pair;
56import android.view.Display;
57import android.view.DragEvent;
58import android.view.MotionEvent;
59import android.view.View;
60import android.view.ViewConfiguration;
61import android.view.ViewGroup;
62import android.view.animation.DecelerateInterpolator;
63import android.widget.ImageView;
64import android.widget.TextView;
65import android.widget.Toast;
66
67import com.android.launcher.R;
68import com.android.launcher2.FolderIcon.FolderRingAnimator;
69import com.android.launcher2.InstallWidgetReceiver.WidgetMimeTypeHandlerData;
70
71import java.util.ArrayList;
72import java.util.HashSet;
73import java.util.List;
74
75/**
76 * The workspace is a wide area with a wallpaper and a finite number of pages.
77 * Each page contains a number of icons, folders or widgets the user can
78 * interact with. A workspace is meant to be used with a fixed width only.
79 */
80public class Workspace extends SmoothPagedView
81        implements DropTarget, DragSource, DragScroller, View.OnTouchListener,
82        DragController.DragListener {
83    @SuppressWarnings({"UnusedDeclaration"})
84    private static final String TAG = "Launcher.Workspace";
85
86    // Y rotation to apply to the workspace screens
87    private static final float WORKSPACE_ROTATION = 12.5f;
88    private static final float WORKSPACE_OVERSCROLL_ROTATION = 24f;
89    private static float CAMERA_DISTANCE = 6500;
90
91    private static final int CHILDREN_OUTLINE_FADE_OUT_DELAY = 0;
92    private static final int CHILDREN_OUTLINE_FADE_OUT_DURATION = 375;
93    private static final int CHILDREN_OUTLINE_FADE_IN_DURATION = 100;
94
95    private static final int BACKGROUND_FADE_OUT_DURATION = 350;
96    private static final int ADJACENT_SCREEN_DROP_DURATION = 300;
97
98    // These animators are used to fade the children's outlines
99    private ObjectAnimator mChildrenOutlineFadeInAnimation;
100    private ObjectAnimator mChildrenOutlineFadeOutAnimation;
101    private float mChildrenOutlineAlpha = 0;
102
103    // These properties refer to the background protection gradient used for AllApps and Customize
104    private ValueAnimator mBackgroundFadeInAnimation;
105    private ValueAnimator mBackgroundFadeOutAnimation;
106    private Drawable mBackground;
107    boolean mDrawBackground = true;
108    private float mBackgroundAlpha = 0;
109    private float mOverScrollMaxBackgroundAlpha = 0.0f;
110    private int mOverScrollPageIndex = -1;
111
112    private float mWallpaperScrollRatio = 1.0f;
113
114    private final WallpaperManager mWallpaperManager;
115    private IBinder mWindowToken;
116    private static final float WALLPAPER_SCREENS_SPAN = 2f;
117
118    private int mDefaultPage;
119
120    /**
121     * CellInfo for the cell that is currently being dragged
122     */
123    private CellLayout.CellInfo mDragInfo;
124
125    /**
126     * Target drop area calculated during last acceptDrop call.
127     */
128    private int[] mTargetCell = new int[2];
129
130    /**
131     * The CellLayout that is currently being dragged over
132     */
133    private CellLayout mDragTargetLayout = null;
134
135    private Launcher mLauncher;
136    private IconCache mIconCache;
137    private DragController mDragController;
138
139    // These are temporary variables to prevent having to allocate a new object just to
140    // return an (x, y) value from helper functions. Do NOT use them to maintain other state.
141    private int[] mTempCell = new int[2];
142    private int[] mTempEstimate = new int[2];
143    private float[] mDragViewVisualCenter = new float[2];
144    private float[] mTempDragCoordinates = new float[2];
145    private float[] mTempCellLayoutCenterCoordinates = new float[2];
146    private float[] mTempDragBottomRightCoordinates = new float[2];
147    private Matrix mTempInverseMatrix = new Matrix();
148
149    private SpringLoadedDragController mSpringLoadedDragController;
150    private float mSpringLoadedShrinkFactor;
151
152    private static final int DEFAULT_CELL_COUNT_X = 4;
153    private static final int DEFAULT_CELL_COUNT_Y = 4;
154
155    // State variable that indicates whether the pages are small (ie when you're
156    // in all apps or customize mode)
157
158    enum State { NORMAL, SPRING_LOADED, SMALL };
159    private State mState = State.NORMAL;
160    private boolean mIsSwitchingState = false;
161    private boolean mSwitchStateAfterFirstLayout = false;
162    private State mStateAfterFirstLayout;
163
164    private AnimatorSet mAnimator;
165    private AnimatorListener mChangeStateAnimationListener;
166
167    boolean mAnimatingViewIntoPlace = false;
168    boolean mIsDragOccuring = false;
169    boolean mChildrenLayersEnabled = true;
170
171    /** Is the user is dragging an item near the edge of a page? */
172    private boolean mInScrollArea = false;
173
174    private final HolographicOutlineHelper mOutlineHelper = new HolographicOutlineHelper();
175    private Bitmap mDragOutline = null;
176    private final Rect mTempRect = new Rect();
177    private final int[] mTempXY = new int[2];
178    private int mDragViewMultiplyColor;
179    private float mOverscrollFade = 0;
180
181    // Paint used to draw external drop outline
182    private final Paint mExternalDragOutlinePaint = new Paint();
183
184    // Camera and Matrix used to determine the final position of a neighboring CellLayout
185    private final Matrix mMatrix = new Matrix();
186    private final Camera mCamera = new Camera();
187    private final float mTempFloat2[] = new float[2];
188
189    enum WallpaperVerticalOffset { TOP, MIDDLE, BOTTOM };
190    int mWallpaperWidth;
191    int mWallpaperHeight;
192    WallpaperOffsetInterpolator mWallpaperOffset;
193    boolean mUpdateWallpaperOffsetImmediately = false;
194    private Runnable mDelayedResizeRunnable;
195    private int mDisplayWidth;
196    private int mDisplayHeight;
197    private int mWallpaperTravelWidth;
198
199    // Variables relating to the creation of user folders by hovering shortcuts over shortcuts
200    private static final int FOLDER_CREATION_TIMEOUT = 250;
201    private final Alarm mFolderCreationAlarm = new Alarm();
202    private FolderRingAnimator mDragFolderRingAnimator = null;
203    private View mLastDragOverView = null;
204    private boolean mCreateUserFolderOnDrop = false;
205
206    // Variables relating to touch disambiguation (scrolling workspace vs. scrolling a widget)
207    private float mXDown;
208    private float mYDown;
209    final static float START_DAMPING_TOUCH_SLOP_ANGLE = (float) Math.PI / 6;
210    final static float MAX_SWIPE_ANGLE = (float) Math.PI / 3;
211    final static float TOUCH_SLOP_DAMPING_FACTOR = 4;
212
213    // These variables are used for storing the initial and final values during workspace animations
214    private int mSavedScrollX;
215    private float mSavedRotationY;
216    private float mSavedTranslationX;
217    private float mCurrentScaleX;
218    private float mCurrentScaleY;
219    private float mCurrentRotationY;
220    private float mCurrentTranslationX;
221    private float mCurrentTranslationY;
222    private float[] mOldTranslationXs;
223    private float[] mOldTranslationYs;
224    private float[] mOldScaleXs;
225    private float[] mOldScaleYs;
226    private float[] mOldBackgroundAlphas;
227    private float[] mOldBackgroundAlphaMultipliers;
228    private float[] mOldAlphas;
229    private float[] mOldRotationYs;
230    private float[] mNewTranslationXs;
231    private float[] mNewTranslationYs;
232    private float[] mNewScaleXs;
233    private float[] mNewScaleYs;
234    private float[] mNewBackgroundAlphas;
235    private float[] mNewBackgroundAlphaMultipliers;
236    private float[] mNewAlphas;
237    private float[] mNewRotationYs;
238    private float mTransitionProgress;
239
240    /**
241     * Used to inflate the Workspace from XML.
242     *
243     * @param context The application's context.
244     * @param attrs The attributes set containing the Workspace's customization values.
245     */
246    public Workspace(Context context, AttributeSet attrs) {
247        this(context, attrs, 0);
248    }
249
250    /**
251     * Used to inflate the Workspace from XML.
252     *
253     * @param context The application's context.
254     * @param attrs The attributes set containing the Workspace's customization values.
255     * @param defStyle Unused.
256     */
257    public Workspace(Context context, AttributeSet attrs, int defStyle) {
258        super(context, attrs, defStyle);
259        mContentIsRefreshable = false;
260
261        // With workspace, data is available straight from the get-go
262        setDataIsReady();
263
264        mFadeInAdjacentScreens =
265            getResources().getBoolean(R.bool.config_workspaceFadeAdjacentScreens);
266        mWallpaperManager = WallpaperManager.getInstance(context);
267
268        int cellCountX = DEFAULT_CELL_COUNT_X;
269        int cellCountY = DEFAULT_CELL_COUNT_Y;
270
271        TypedArray a = context.obtainStyledAttributes(attrs,
272                R.styleable.Workspace, defStyle, 0);
273
274        final Resources res = context.getResources();
275        if (LauncherApplication.isScreenLarge()) {
276            // Determine number of rows/columns dynamically
277            // TODO: This code currently fails on tablets with an aspect ratio < 1.3.
278            // Around that ratio we should make cells the same size in portrait and
279            // landscape
280            TypedArray actionBarSizeTypedArray =
281                context.obtainStyledAttributes(new int[] { android.R.attr.actionBarSize });
282            final float actionBarHeight = actionBarSizeTypedArray.getDimension(0, 0f);
283            final float systemBarHeight = res.getDimension(R.dimen.status_bar_height);
284            final float smallestScreenDim = res.getConfiguration().smallestScreenWidthDp;
285
286            cellCountX = 1;
287            while (CellLayout.widthInPortrait(res, cellCountX + 1) <= smallestScreenDim) {
288                cellCountX++;
289            }
290
291            cellCountY = 1;
292            while (actionBarHeight + CellLayout.heightInLandscape(res, cellCountY + 1)
293                <= smallestScreenDim - systemBarHeight) {
294                cellCountY++;
295            }
296        }
297
298        mSpringLoadedShrinkFactor =
299            res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f;
300        mDragViewMultiplyColor = res.getColor(R.color.drag_view_multiply_color);
301
302        // if the value is manually specified, use that instead
303        cellCountX = a.getInt(R.styleable.Workspace_cellCountX, cellCountX);
304        cellCountY = a.getInt(R.styleable.Workspace_cellCountY, cellCountY);
305        mDefaultPage = a.getInt(R.styleable.Workspace_defaultScreen, 1);
306        a.recycle();
307
308        LauncherModel.updateWorkspaceLayoutCells(cellCountX, cellCountY);
309        setHapticFeedbackEnabled(false);
310
311        mLauncher = (Launcher) context;
312        initWorkspace();
313
314        // Disable multitouch across the workspace/all apps/customize tray
315        setMotionEventSplittingEnabled(true);
316    }
317
318    // estimate the size of a widget with spans hSpan, vSpan. return MAX_VALUE for each
319    // dimension if unsuccessful
320    public int[] estimateItemSize(int hSpan, int vSpan,
321            PendingAddItemInfo pendingItemInfo, boolean springLoaded) {
322        int[] size = new int[2];
323        if (getChildCount() > 0) {
324            CellLayout cl = (CellLayout) mLauncher.getWorkspace().getChildAt(0);
325            RectF r = estimateItemPosition(cl, pendingItemInfo, 0, 0, hSpan, vSpan);
326            size[0] = (int) r.width();
327            size[1] = (int) r.height();
328            if (springLoaded) {
329                size[0] *= mSpringLoadedShrinkFactor;
330                size[1] *= mSpringLoadedShrinkFactor;
331            }
332            return size;
333        } else {
334            size[0] = Integer.MAX_VALUE;
335            size[1] = Integer.MAX_VALUE;
336            return size;
337        }
338    }
339    public RectF estimateItemPosition(CellLayout cl, ItemInfo pendingInfo,
340            int hCell, int vCell, int hSpan, int vSpan) {
341        RectF r = new RectF();
342        cl.cellToRect(hCell, vCell, hSpan, vSpan, r);
343        if (pendingInfo instanceof PendingAddWidgetInfo) {
344            PendingAddWidgetInfo widgetInfo = (PendingAddWidgetInfo) pendingInfo;
345            Rect p = AppWidgetHostView.getDefaultPaddingForWidget(mContext,
346                    widgetInfo.componentName, null);
347            r.top += p.top;
348            r.left += p.left;
349            r.right -= p.right;
350            r.bottom -= p.bottom;
351        }
352        return r;
353    }
354
355    public void buildPageHardwareLayers() {
356        if (getWindowToken() != null) {
357            final int childCount = getChildCount();
358            for (int i = 0; i < childCount; i++) {
359                CellLayout cl = (CellLayout) getChildAt(i);
360                cl.buildChildrenLayer();
361            }
362        }
363    }
364
365    public void onDragStart(DragSource source, Object info, int dragAction) {
366        mIsDragOccuring = true;
367        updateChildrenLayersEnabled();
368        mLauncher.lockScreenOrientationOnLargeUI();
369    }
370
371    public void onDragEnd() {
372        mIsDragOccuring = false;
373        updateChildrenLayersEnabled();
374        mLauncher.unlockScreenOrientationOnLargeUI();
375    }
376
377    /**
378     * Initializes various states for this workspace.
379     */
380    protected void initWorkspace() {
381        Context context = getContext();
382        mCurrentPage = mDefaultPage;
383        Launcher.setScreen(mCurrentPage);
384        LauncherApplication app = (LauncherApplication)context.getApplicationContext();
385        mIconCache = app.getIconCache();
386        mExternalDragOutlinePaint.setAntiAlias(true);
387        setWillNotDraw(false);
388        setChildrenDrawnWithCacheEnabled(true);
389
390        try {
391            final Resources res = getResources();
392            mBackground = res.getDrawable(R.drawable.apps_customize_bg);
393        } catch (Resources.NotFoundException e) {
394            // In this case, we will skip drawing background protection
395        }
396
397        mChangeStateAnimationListener = new AnimatorListenerAdapter() {
398            @Override
399            public void onAnimationStart(Animator animation) {
400                mIsSwitchingState = true;
401            }
402
403            @Override
404            public void onAnimationEnd(Animator animation) {
405                mIsSwitchingState = false;
406                mWallpaperOffset.setOverrideHorizontalCatchupConstant(false);
407                mAnimator = null;
408                updateChildrenLayersEnabled();
409            }
410        };
411
412        mSnapVelocity = 600;
413        mWallpaperOffset = new WallpaperOffsetInterpolator();
414        Display display = mLauncher.getWindowManager().getDefaultDisplay();
415        mDisplayWidth = display.getWidth();
416        mDisplayHeight = display.getHeight();
417        mWallpaperTravelWidth = (int) (mDisplayWidth *
418                wallpaperTravelToScreenWidthRatio(mDisplayWidth, mDisplayHeight));
419    }
420
421    @Override
422    protected int getScrollMode() {
423        return SmoothPagedView.X_LARGE_MODE;
424    }
425
426    @Override
427    protected void onViewAdded(View child) {
428        super.onViewAdded(child);
429        if (!(child instanceof CellLayout)) {
430            throw new IllegalArgumentException("A Workspace can only have CellLayout children.");
431        }
432        CellLayout cl = ((CellLayout) child);
433        cl.setOnInterceptTouchListener(this);
434        cl.setClickable(true);
435        cl.enableHardwareLayers();
436    }
437
438    /**
439     * @return The open folder on the current screen, or null if there is none
440     */
441    Folder getOpenFolder() {
442        DragLayer dragLayer = mLauncher.getDragLayer();
443        int count = dragLayer.getChildCount();
444        for (int i = 0; i < count; i++) {
445            View child = dragLayer.getChildAt(i);
446            if (child instanceof Folder) {
447                Folder folder = (Folder) child;
448                if (folder.getInfo().opened)
449                    return folder;
450            }
451        }
452        return null;
453    }
454
455    boolean isTouchActive() {
456        return mTouchState != TOUCH_STATE_REST;
457    }
458
459    /**
460     * Adds the specified child in the specified screen. The position and dimension of
461     * the child are defined by x, y, spanX and spanY.
462     *
463     * @param child The child to add in one of the workspace's screens.
464     * @param screen The screen in which to add the child.
465     * @param x The X position of the child in the screen's grid.
466     * @param y The Y position of the child in the screen's grid.
467     * @param spanX The number of cells spanned horizontally by the child.
468     * @param spanY The number of cells spanned vertically by the child.
469     */
470    void addInScreen(View child, long container, int screen, int x, int y, int spanX, int spanY) {
471        addInScreen(child, container, screen, x, y, spanX, spanY, false);
472    }
473
474    /**
475     * Adds the specified child in the specified screen. The position and dimension of
476     * the child are defined by x, y, spanX and spanY.
477     *
478     * @param child The child to add in one of the workspace's screens.
479     * @param screen The screen in which to add the child.
480     * @param x The X position of the child in the screen's grid.
481     * @param y The Y position of the child in the screen's grid.
482     * @param spanX The number of cells spanned horizontally by the child.
483     * @param spanY The number of cells spanned vertically by the child.
484     * @param insert When true, the child is inserted at the beginning of the children list.
485     */
486    void addInScreen(View child, long container, int screen, int x, int y, int spanX, int spanY,
487            boolean insert) {
488        if (container == LauncherSettings.Favorites.CONTAINER_DESKTOP) {
489            if (screen < 0 || screen >= getChildCount()) {
490                Log.e(TAG, "The screen must be >= 0 and < " + getChildCount()
491                    + " (was " + screen + "); skipping child");
492                return;
493            }
494        }
495
496        final CellLayout layout;
497        if (container == LauncherSettings.Favorites.CONTAINER_HOTSEAT) {
498            layout = mLauncher.getHotseat().getLayout();
499            child.setOnKeyListener(null);
500
501            // Hide folder title in the hotseat
502            if (child instanceof FolderIcon) {
503                ((FolderIcon) child).setTextVisible(false);
504            }
505
506            if (screen < 0) {
507                screen = mLauncher.getHotseat().getOrderInHotseat(x, y);
508            } else {
509                // Note: We do this to ensure that the hotseat is always laid out in the orientation
510                // of the hotseat in order regardless of which orientation they were added
511                x = mLauncher.getHotseat().getCellXFromOrder(screen);
512                y = mLauncher.getHotseat().getCellYFromOrder(screen);
513            }
514        } else {
515            // Show folder title if not in the hotseat
516            if (child instanceof FolderIcon) {
517                ((FolderIcon) child).setTextVisible(true);
518            }
519
520            layout = (CellLayout) getChildAt(screen);
521            child.setOnKeyListener(new IconKeyEventListener());
522        }
523
524        CellLayout.LayoutParams lp = (CellLayout.LayoutParams) child.getLayoutParams();
525        if (lp == null) {
526            lp = new CellLayout.LayoutParams(x, y, spanX, spanY);
527        } else {
528            lp.cellX = x;
529            lp.cellY = y;
530            lp.cellHSpan = spanX;
531            lp.cellVSpan = spanY;
532        }
533
534        if (spanX < 0 && spanY < 0) {
535            lp.isLockedToGrid = false;
536        }
537
538        // Get the canonical child id to uniquely represent this view in this screen
539        int childId = LauncherModel.getCellLayoutChildId(container, screen, x, y, spanX, spanY);
540        boolean markCellsAsOccupied = !(child instanceof Folder);
541        if (!layout.addViewToCellLayout(child, insert ? 0 : -1, childId, lp, markCellsAsOccupied)) {
542            // TODO: This branch occurs when the workspace is adding views
543            // outside of the defined grid
544            // maybe we should be deleting these items from the LauncherModel?
545            Log.w(TAG, "Failed to add to item at (" + lp.cellX + "," + lp.cellY + ") to CellLayout");
546        }
547
548        if (!(child instanceof Folder)) {
549            child.setHapticFeedbackEnabled(false);
550            child.setOnLongClickListener(mLongClickListener);
551        }
552        if (child instanceof DropTarget) {
553            mDragController.addDropTarget((DropTarget) child);
554        }
555    }
556
557    /**
558     * Check if the point (x, y) hits a given page.
559     */
560    private boolean hitsPage(int index, float x, float y) {
561        final View page = getChildAt(index);
562        if (page != null) {
563            float[] localXY = { x, y };
564            mapPointFromSelfToChild(page, localXY);
565            return (localXY[0] >= 0 && localXY[0] < page.getWidth()
566                    && localXY[1] >= 0 && localXY[1] < page.getHeight());
567        }
568        return false;
569    }
570
571    @Override
572    protected boolean hitsPreviousPage(float x, float y) {
573        // mNextPage is set to INVALID_PAGE whenever we are stationary.
574        // Calculating "next page" this way ensures that you scroll to whatever page you tap on
575        final int current = (mNextPage == INVALID_PAGE) ? mCurrentPage : mNextPage;
576
577        // Only allow tap to next page on large devices, where there's significant margin outside
578        // the active workspace
579        return LauncherApplication.isScreenLarge() && hitsPage(current - 1, x, y);
580    }
581
582    @Override
583    protected boolean hitsNextPage(float x, float y) {
584        // mNextPage is set to INVALID_PAGE whenever we are stationary.
585        // Calculating "next page" this way ensures that you scroll to whatever page you tap on
586        final int current = (mNextPage == INVALID_PAGE) ? mCurrentPage : mNextPage;
587
588        // Only allow tap to next page on large devices, where there's significant margin outside
589        // the active workspace
590        return LauncherApplication.isScreenLarge() && hitsPage(current + 1, x, y);
591    }
592
593    /**
594     * Called directly from a CellLayout (not by the framework), after we've been added as a
595     * listener via setOnInterceptTouchEventListener(). This allows us to tell the CellLayout
596     * that it should intercept touch events, which is not something that is normally supported.
597     */
598    @Override
599    public boolean onTouch(View v, MotionEvent event) {
600        return (isSmall() || mIsSwitchingState);
601    }
602
603    public boolean isSwitchingState() {
604        return mIsSwitchingState;
605    }
606
607    protected void onWindowVisibilityChanged (int visibility) {
608        mLauncher.onWindowVisibilityChanged(visibility);
609    }
610
611    @Override
612    public boolean dispatchUnhandledMove(View focused, int direction) {
613        if (isSmall() || mIsSwitchingState) {
614            // when the home screens are shrunken, shouldn't allow side-scrolling
615            return false;
616        }
617        return super.dispatchUnhandledMove(focused, direction);
618    }
619
620    @Override
621    public boolean onInterceptTouchEvent(MotionEvent ev) {
622        switch (ev.getAction() & MotionEvent.ACTION_MASK) {
623        case MotionEvent.ACTION_DOWN:
624            mXDown = ev.getX();
625            mYDown = ev.getY();
626            break;
627        case MotionEvent.ACTION_POINTER_UP:
628        case MotionEvent.ACTION_UP:
629            if (mTouchState == TOUCH_STATE_REST) {
630                final CellLayout currentPage = (CellLayout) getChildAt(mCurrentPage);
631                if (!currentPage.lastDownOnOccupiedCell()) {
632                    onWallpaperTap(ev);
633                }
634            }
635        }
636        return super.onInterceptTouchEvent(ev);
637    }
638
639    @Override
640    protected void determineScrollingStart(MotionEvent ev) {
641        if (!isSmall() && !mIsSwitchingState) {
642            float deltaX = Math.abs(ev.getX() - mXDown);
643            float deltaY = Math.abs(ev.getY() - mYDown);
644
645            if (Float.compare(deltaX, 0f) == 0) return;
646
647            float slope = deltaY / deltaX;
648            float theta = (float) Math.atan(slope);
649
650            if (deltaX > mTouchSlop || deltaY > mTouchSlop) {
651                cancelCurrentPageLongPress();
652            }
653
654            if (theta > MAX_SWIPE_ANGLE) {
655                // Above MAX_SWIPE_ANGLE, we don't want to ever start scrolling the workspace
656                return;
657            } else if (theta > START_DAMPING_TOUCH_SLOP_ANGLE) {
658                // Above START_DAMPING_TOUCH_SLOP_ANGLE and below MAX_SWIPE_ANGLE, we want to
659                // increase the touch slop to make it harder to begin scrolling the workspace. This
660                // results in vertically scrolling widgets to more easily. The higher the angle, the
661                // more we increase touch slop.
662                theta -= START_DAMPING_TOUCH_SLOP_ANGLE;
663                float extraRatio = (float)
664                        Math.sqrt((theta / (MAX_SWIPE_ANGLE - START_DAMPING_TOUCH_SLOP_ANGLE)));
665                super.determineScrollingStart(ev, 1 + TOUCH_SLOP_DAMPING_FACTOR * extraRatio);
666            } else {
667                // Below START_DAMPING_TOUCH_SLOP_ANGLE, we don't do anything special
668                super.determineScrollingStart(ev);
669            }
670        }
671    }
672
673    @Override
674    protected boolean isScrollingIndicatorEnabled() {
675        return mState != State.SPRING_LOADED;
676    }
677
678    protected void onPageBeginMoving() {
679        super.onPageBeginMoving();
680
681        if (isHardwareAccelerated()) {
682            updateChildrenLayersEnabled();
683        } else {
684            if (mNextPage != INVALID_PAGE) {
685                // we're snapping to a particular screen
686                enableChildrenCache(mCurrentPage, mNextPage);
687            } else {
688                // this is when user is actively dragging a particular screen, they might
689                // swipe it either left or right (but we won't advance by more than one screen)
690                enableChildrenCache(mCurrentPage - 1, mCurrentPage + 1);
691            }
692        }
693
694        // Only show page outlines as we pan if we are on large screen
695        if (LauncherApplication.isScreenLarge()) {
696            showOutlines();
697        }
698    }
699
700    protected void onPageEndMoving() {
701        super.onPageEndMoving();
702
703        if (isHardwareAccelerated()) {
704            updateChildrenLayersEnabled();
705        } else {
706            clearChildrenCache();
707        }
708
709        // Hide the outlines, as long as we're not dragging
710        if (!mDragController.dragging()) {
711            // Only hide page outlines as we pan if we are on large screen
712            if (LauncherApplication.isScreenLarge()) {
713                hideOutlines();
714            }
715        }
716        mOverScrollMaxBackgroundAlpha = 0.0f;
717        mOverScrollPageIndex = -1;
718
719        if (mDelayedResizeRunnable != null) {
720            mDelayedResizeRunnable.run();
721            mDelayedResizeRunnable = null;
722        }
723    }
724
725    @Override
726    protected void notifyPageSwitchListener() {
727        super.notifyPageSwitchListener();
728        Launcher.setScreen(mCurrentPage);
729    };
730
731    // As a ratio of screen height, the total distance we want the parallax effect to span
732    // horizontally
733    private float wallpaperTravelToScreenWidthRatio(int width, int height) {
734        float aspectRatio = width / (float) height;
735
736        // At an aspect ratio of 16/10, the wallpaper parallax effect should span 1.5 * screen width
737        // At an aspect ratio of 10/16, the wallpaper parallax effect should span 1.2 * screen width
738        // We will use these two data points to extrapolate how much the wallpaper parallax effect
739        // to span (ie travel) at any aspect ratio:
740
741        final float ASPECT_RATIO_LANDSCAPE = 16/10f;
742        final float ASPECT_RATIO_PORTRAIT = 10/16f;
743        final float WALLPAPER_WIDTH_TO_SCREEN_RATIO_LANDSCAPE = 1.5f;
744        final float WALLPAPER_WIDTH_TO_SCREEN_RATIO_PORTRAIT = 1.2f;
745
746        // To find out the desired width at different aspect ratios, we use the following two
747        // formulas, where the coefficient on x is the aspect ratio (width/height):
748        //   (16/10)x + y = 1.5
749        //   (10/16)x + y = 1.2
750        // We solve for x and y and end up with a final formula:
751        final float x =
752            (WALLPAPER_WIDTH_TO_SCREEN_RATIO_LANDSCAPE - WALLPAPER_WIDTH_TO_SCREEN_RATIO_PORTRAIT) /
753            (ASPECT_RATIO_LANDSCAPE - ASPECT_RATIO_PORTRAIT);
754        final float y = WALLPAPER_WIDTH_TO_SCREEN_RATIO_PORTRAIT - x * ASPECT_RATIO_PORTRAIT;
755        return x * aspectRatio + y;
756    }
757
758    // The range of scroll values for Workspace
759    private int getScrollRange() {
760        return getChildOffset(getChildCount() - 1) - getChildOffset(0);
761    }
762
763    protected void setWallpaperDimension() {
764        DisplayMetrics displayMetrics = new DisplayMetrics();
765        mLauncher.getWindowManager().getDefaultDisplay().getRealMetrics(displayMetrics);
766        final int maxDim = Math.max(displayMetrics.widthPixels, displayMetrics.heightPixels);
767        final int minDim = Math.min(displayMetrics.widthPixels, displayMetrics.heightPixels);
768
769        // We need to ensure that there is enough extra space in the wallpaper for the intended
770        // parallax effects
771        if (LauncherApplication.isScreenLarge()) {
772            mWallpaperWidth = (int) (maxDim * wallpaperTravelToScreenWidthRatio(maxDim, minDim));
773            mWallpaperHeight = maxDim;
774        } else {
775            mWallpaperWidth = Math.max((int) (minDim * WALLPAPER_SCREENS_SPAN), maxDim);
776            mWallpaperHeight = maxDim;
777        }
778        new Thread("setWallpaperDimension") {
779            public void run() {
780                mWallpaperManager.suggestDesiredDimensions(mWallpaperWidth, mWallpaperHeight);
781            }
782        }.start();
783    }
784
785    public void setVerticalWallpaperOffset(float offset) {
786        mWallpaperOffset.setFinalY(offset);
787    }
788    public float getVerticalWallpaperOffset() {
789        return mWallpaperOffset.getCurrY();
790    }
791    public void setHorizontalWallpaperOffset(float offset) {
792        mWallpaperOffset.setFinalX(offset);
793    }
794    public float getHorizontalWallpaperOffset() {
795        return mWallpaperOffset.getCurrX();
796    }
797
798    private float wallpaperOffsetForCurrentScroll() {
799        // The wallpaper travel width is how far, from left to right, the wallpaper will move
800        // at this orientation. On tablets in portrait mode we don't move all the way to the
801        // edges of the wallpaper, or otherwise the parallax effect would be too strong.
802        int wallpaperTravelWidth = mWallpaperWidth;
803        if (LauncherApplication.isScreenLarge()) {
804            wallpaperTravelWidth = mWallpaperTravelWidth;
805        }
806
807        // Set wallpaper offset steps (1 / (number of screens - 1))
808        mWallpaperManager.setWallpaperOffsetSteps(1.0f / (getChildCount() - 1), 1.0f);
809
810        // For the purposes of computing the scrollRange and overScrollOffset, we assume
811        // that mLayoutScale is 1. This means that when we're in spring-loaded mode,
812        // there's no discrepancy between the wallpaper offset for a given page.
813        float layoutScale = mLayoutScale;
814        mLayoutScale = 1f;
815        int scrollRange = getScrollRange();
816
817        // Again, we adjust the wallpaper offset to be consistent between values of mLayoutScale
818        float adjustedScrollX = Math.max(0, Math.min(mScrollX, mMaxScrollX));
819        adjustedScrollX *= mWallpaperScrollRatio;
820        mLayoutScale = layoutScale;
821
822        float scrollProgress =
823            adjustedScrollX / (float) scrollRange;
824        float offsetInDips = wallpaperTravelWidth * scrollProgress +
825            (mWallpaperWidth - wallpaperTravelWidth) / 2; // center it
826        float offset = offsetInDips / (float) mWallpaperWidth;
827        return offset;
828    }
829    private void syncWallpaperOffsetWithScroll() {
830        final boolean enableWallpaperEffects = isHardwareAccelerated();
831        if (enableWallpaperEffects) {
832            mWallpaperOffset.setFinalX(wallpaperOffsetForCurrentScroll());
833        }
834    }
835
836    public void updateWallpaperOffsetImmediately() {
837        mUpdateWallpaperOffsetImmediately = true;
838    }
839
840    private void updateWallpaperOffsets() {
841        boolean updateNow = false;
842        boolean keepUpdating = true;
843        if (mUpdateWallpaperOffsetImmediately) {
844            updateNow = true;
845            keepUpdating = false;
846            mWallpaperOffset.jumpToFinal();
847            mUpdateWallpaperOffsetImmediately = false;
848        } else {
849            updateNow = keepUpdating = mWallpaperOffset.computeScrollOffset();
850        }
851        if (updateNow) {
852            if (mWindowToken != null) {
853                mWallpaperManager.setWallpaperOffsets(mWindowToken,
854                        mWallpaperOffset.getCurrX(), mWallpaperOffset.getCurrY());
855            }
856        }
857        if (keepUpdating) {
858            fastInvalidate();
859        }
860    }
861
862    @Override
863    protected void updateCurrentPageScroll() {
864        super.updateCurrentPageScroll();
865        computeWallpaperScrollRatio(mCurrentPage);
866    }
867
868    @Override
869    protected void snapToPage(int whichPage) {
870        super.snapToPage(whichPage);
871        computeWallpaperScrollRatio(whichPage);
872    }
873
874    private void computeWallpaperScrollRatio(int page) {
875        // Here, we determine what the desired scroll would be with and without a layout scale,
876        // and compute a ratio between the two. This allows us to adjust the wallpaper offset
877        // as though there is no layout scale.
878        float layoutScale = mLayoutScale;
879        int scaled = getChildOffset(page) - getRelativeChildOffset(page);
880        mLayoutScale = 1.0f;
881        float unscaled = getChildOffset(page) - getRelativeChildOffset(page);
882        mLayoutScale = layoutScale;
883        if (scaled > 0) {
884            mWallpaperScrollRatio = (1.0f * unscaled) / scaled;
885        } else {
886            mWallpaperScrollRatio = 1f;
887        }
888    }
889
890    class WallpaperOffsetInterpolator {
891        float mFinalHorizontalWallpaperOffset = 0.0f;
892        float mFinalVerticalWallpaperOffset = 0.5f;
893        float mHorizontalWallpaperOffset = 0.0f;
894        float mVerticalWallpaperOffset = 0.5f;
895        long mLastWallpaperOffsetUpdateTime;
896        boolean mIsMovingFast;
897        boolean mOverrideHorizontalCatchupConstant;
898        float mHorizontalCatchupConstant = 0.35f;
899        float mVerticalCatchupConstant = 0.35f;
900
901        public WallpaperOffsetInterpolator() {
902        }
903
904        public void setOverrideHorizontalCatchupConstant(boolean override) {
905            mOverrideHorizontalCatchupConstant = override;
906        }
907
908        public void setHorizontalCatchupConstant(float f) {
909            mHorizontalCatchupConstant = f;
910        }
911
912        public void setVerticalCatchupConstant(float f) {
913            mVerticalCatchupConstant = f;
914        }
915
916        public boolean computeScrollOffset() {
917            if (Float.compare(mHorizontalWallpaperOffset, mFinalHorizontalWallpaperOffset) == 0 &&
918                    Float.compare(mVerticalWallpaperOffset, mFinalVerticalWallpaperOffset) == 0) {
919                mIsMovingFast = false;
920                return false;
921            }
922            boolean isLandscape = mDisplayWidth > mDisplayHeight;
923
924            long currentTime = System.currentTimeMillis();
925            long timeSinceLastUpdate = currentTime - mLastWallpaperOffsetUpdateTime;
926            timeSinceLastUpdate = Math.min((long) (1000/30f), timeSinceLastUpdate);
927            timeSinceLastUpdate = Math.max(1L, timeSinceLastUpdate);
928
929            float xdiff = Math.abs(mFinalHorizontalWallpaperOffset - mHorizontalWallpaperOffset);
930            if (!mIsMovingFast && xdiff > 0.07) {
931                mIsMovingFast = true;
932            }
933
934            float fractionToCatchUpIn1MsHorizontal;
935            if (mOverrideHorizontalCatchupConstant) {
936                fractionToCatchUpIn1MsHorizontal = mHorizontalCatchupConstant;
937            } else if (mIsMovingFast) {
938                fractionToCatchUpIn1MsHorizontal = isLandscape ? 0.5f : 0.75f;
939            } else {
940                // slow
941                fractionToCatchUpIn1MsHorizontal = isLandscape ? 0.27f : 0.5f;
942            }
943            float fractionToCatchUpIn1MsVertical = mVerticalCatchupConstant;
944
945            fractionToCatchUpIn1MsHorizontal /= 33f;
946            fractionToCatchUpIn1MsVertical /= 33f;
947
948            final float UPDATE_THRESHOLD = 0.00001f;
949            float hOffsetDelta = mFinalHorizontalWallpaperOffset - mHorizontalWallpaperOffset;
950            float vOffsetDelta = mFinalVerticalWallpaperOffset - mVerticalWallpaperOffset;
951            boolean jumpToFinalValue = Math.abs(hOffsetDelta) < UPDATE_THRESHOLD &&
952                Math.abs(vOffsetDelta) < UPDATE_THRESHOLD;
953
954            // Don't have any lag between workspace and wallpaper on non-large devices
955            if (!LauncherApplication.isScreenLarge() || jumpToFinalValue) {
956                mHorizontalWallpaperOffset = mFinalHorizontalWallpaperOffset;
957                mVerticalWallpaperOffset = mFinalVerticalWallpaperOffset;
958            } else {
959                float percentToCatchUpVertical =
960                    Math.min(1.0f, timeSinceLastUpdate * fractionToCatchUpIn1MsVertical);
961                float percentToCatchUpHorizontal =
962                    Math.min(1.0f, timeSinceLastUpdate * fractionToCatchUpIn1MsHorizontal);
963                mHorizontalWallpaperOffset += percentToCatchUpHorizontal * hOffsetDelta;
964                mVerticalWallpaperOffset += percentToCatchUpVertical * vOffsetDelta;
965            }
966
967            mLastWallpaperOffsetUpdateTime = System.currentTimeMillis();
968            return true;
969        }
970
971        public float getCurrX() {
972            return mHorizontalWallpaperOffset;
973        }
974
975        public float getFinalX() {
976            return mFinalHorizontalWallpaperOffset;
977        }
978
979        public float getCurrY() {
980            return mVerticalWallpaperOffset;
981        }
982
983        public float getFinalY() {
984            return mFinalVerticalWallpaperOffset;
985        }
986
987        public void setFinalX(float x) {
988            mFinalHorizontalWallpaperOffset = Math.max(0f, Math.min(x, 1.0f));
989        }
990
991        public void setFinalY(float y) {
992            mFinalVerticalWallpaperOffset = Math.max(0f, Math.min(y, 1.0f));
993        }
994
995        public void jumpToFinal() {
996            mHorizontalWallpaperOffset = mFinalHorizontalWallpaperOffset;
997            mVerticalWallpaperOffset = mFinalVerticalWallpaperOffset;
998        }
999    }
1000
1001    @Override
1002    public void computeScroll() {
1003        super.computeScroll();
1004        syncWallpaperOffsetWithScroll();
1005    }
1006
1007    void showOutlines() {
1008        if (!isSmall() && !mIsSwitchingState) {
1009            if (mChildrenOutlineFadeOutAnimation != null) mChildrenOutlineFadeOutAnimation.cancel();
1010            if (mChildrenOutlineFadeInAnimation != null) mChildrenOutlineFadeInAnimation.cancel();
1011            mChildrenOutlineFadeInAnimation = ObjectAnimator.ofFloat(this, "childrenOutlineAlpha", 1.0f);
1012            mChildrenOutlineFadeInAnimation.setDuration(CHILDREN_OUTLINE_FADE_IN_DURATION);
1013            mChildrenOutlineFadeInAnimation.start();
1014        }
1015    }
1016
1017    void hideOutlines() {
1018        if (!isSmall() && !mIsSwitchingState) {
1019            if (mChildrenOutlineFadeInAnimation != null) mChildrenOutlineFadeInAnimation.cancel();
1020            if (mChildrenOutlineFadeOutAnimation != null) mChildrenOutlineFadeOutAnimation.cancel();
1021            mChildrenOutlineFadeOutAnimation = ObjectAnimator.ofFloat(this, "childrenOutlineAlpha", 0.0f);
1022            mChildrenOutlineFadeOutAnimation.setDuration(CHILDREN_OUTLINE_FADE_OUT_DURATION);
1023            mChildrenOutlineFadeOutAnimation.setStartDelay(CHILDREN_OUTLINE_FADE_OUT_DELAY);
1024            mChildrenOutlineFadeOutAnimation.start();
1025        }
1026    }
1027
1028    public void showOutlinesTemporarily() {
1029        if (!mIsPageMoving && !isTouchActive()) {
1030            snapToPage(mCurrentPage);
1031        }
1032    }
1033
1034    public void setChildrenOutlineAlpha(float alpha) {
1035        mChildrenOutlineAlpha = alpha;
1036        for (int i = 0; i < getChildCount(); i++) {
1037            CellLayout cl = (CellLayout) getChildAt(i);
1038            cl.setBackgroundAlpha(alpha);
1039        }
1040    }
1041
1042    public float getChildrenOutlineAlpha() {
1043        return mChildrenOutlineAlpha;
1044    }
1045
1046    void disableBackground() {
1047        mDrawBackground = false;
1048    }
1049    void enableBackground() {
1050        mDrawBackground = true;
1051    }
1052
1053    private void animateBackgroundGradient(float finalAlpha, boolean animated) {
1054        if (mBackground == null) return;
1055        if (mBackgroundFadeInAnimation != null) {
1056            mBackgroundFadeInAnimation.cancel();
1057            mBackgroundFadeInAnimation = null;
1058        }
1059        if (mBackgroundFadeOutAnimation != null) {
1060            mBackgroundFadeOutAnimation.cancel();
1061            mBackgroundFadeOutAnimation = null;
1062        }
1063        float startAlpha = getBackgroundAlpha();
1064        if (finalAlpha != startAlpha) {
1065            if (animated) {
1066                mBackgroundFadeOutAnimation = ValueAnimator.ofFloat(startAlpha, finalAlpha);
1067                mBackgroundFadeOutAnimation.addUpdateListener(new AnimatorUpdateListener() {
1068                    public void onAnimationUpdate(ValueAnimator animation) {
1069                        setBackgroundAlpha(((Float) animation.getAnimatedValue()).floatValue());
1070                    }
1071                });
1072                mBackgroundFadeOutAnimation.setInterpolator(new DecelerateInterpolator(1.5f));
1073                mBackgroundFadeOutAnimation.setDuration(BACKGROUND_FADE_OUT_DURATION);
1074                mBackgroundFadeOutAnimation.start();
1075            } else {
1076                setBackgroundAlpha(finalAlpha);
1077            }
1078        }
1079    }
1080
1081    public void setBackgroundAlpha(float alpha) {
1082        if (alpha != mBackgroundAlpha) {
1083            mBackgroundAlpha = alpha;
1084            invalidate();
1085        }
1086    }
1087
1088    public float getBackgroundAlpha() {
1089        return mBackgroundAlpha;
1090    }
1091
1092    /**
1093     * Due to 3D transformations, if two CellLayouts are theoretically touching each other,
1094     * on the xy plane, when one is rotated along the y-axis, the gap between them is perceived
1095     * as being larger. This method computes what offset the rotated view should be translated
1096     * in order to minimize this perceived gap.
1097     * @param degrees Angle of the view
1098     * @param width Width of the view
1099     * @param height Height of the view
1100     * @return Offset to be used in a View.setTranslationX() call
1101     */
1102    private float getOffsetXForRotation(float degrees, int width, int height) {
1103        mMatrix.reset();
1104        mCamera.save();
1105        mCamera.rotateY(Math.abs(degrees));
1106        mCamera.getMatrix(mMatrix);
1107        mCamera.restore();
1108
1109        mMatrix.preTranslate(-width * 0.5f, -height * 0.5f);
1110        mMatrix.postTranslate(width * 0.5f, height * 0.5f);
1111        mTempFloat2[0] = width;
1112        mTempFloat2[1] = height;
1113        mMatrix.mapPoints(mTempFloat2);
1114        return (width - mTempFloat2[0]) * (degrees > 0.0f ? 1.0f : -1.0f);
1115    }
1116
1117    float backgroundAlphaInterpolator(float r) {
1118        float pivotA = 0.1f;
1119        float pivotB = 0.4f;
1120        if (r < pivotA) {
1121            return 0;
1122        } else if (r > pivotB) {
1123            return 1.0f;
1124        } else {
1125            return (r - pivotA)/(pivotB - pivotA);
1126        }
1127    }
1128
1129    float overScrollBackgroundAlphaInterpolator(float r) {
1130        float threshold = 0.08f;
1131
1132        if (r > mOverScrollMaxBackgroundAlpha) {
1133            mOverScrollMaxBackgroundAlpha = r;
1134        } else if (r < mOverScrollMaxBackgroundAlpha) {
1135            r = mOverScrollMaxBackgroundAlpha;
1136        }
1137
1138        return Math.min(r / threshold, 1.0f);
1139    }
1140
1141    private void screenScrolledLargeUI(int screenCenter) {
1142        if (isSwitchingState()) return;
1143        boolean isInOverscroll = false;
1144        for (int i = 0; i < getChildCount(); i++) {
1145            CellLayout cl = (CellLayout) getChildAt(i);
1146            if (cl != null) {
1147                float scrollProgress = getScrollProgress(screenCenter, cl, i);
1148                float rotation = WORKSPACE_ROTATION * scrollProgress;
1149                float translationX = getOffsetXForRotation(rotation, cl.getWidth(), cl.getHeight());
1150
1151                // If the current page (i) is being over scrolled, we use a different
1152                // set of rules for setting the background alpha multiplier.
1153                if (!isSmall()) {
1154                    if ((mOverScrollX < 0 && i == 0) || (mOverScrollX > mMaxScrollX &&
1155                            i == getChildCount() -1)) {
1156                        isInOverscroll = true;
1157                        rotation *= -1;
1158                        cl.setBackgroundAlphaMultiplier(
1159                                overScrollBackgroundAlphaInterpolator(Math.abs(scrollProgress)));
1160                        mOverScrollPageIndex = i;
1161                        cl.setOverScrollAmount(Math.abs(scrollProgress), i == 0);
1162                        cl.setPivotX(cl.getMeasuredWidth() * (i == 0 ? 0.75f : 0.25f));
1163                        cl.setPivotY(cl.getMeasuredHeight() * 0.5f);
1164                        cl.setOverscrollTransformsDirty(true);
1165                    } else if (mOverScrollPageIndex != i) {
1166                        cl.setBackgroundAlphaMultiplier(
1167                                backgroundAlphaInterpolator(Math.abs(scrollProgress)));
1168                    }
1169                }
1170                cl.setFastTranslationX(translationX);
1171                cl.setFastRotationY(rotation);
1172                if (mFadeInAdjacentScreens && !isSmall()) {
1173                    float alpha = 1 - Math.abs(scrollProgress);
1174                    cl.setFastAlpha(alpha);
1175                }
1176                cl.fastInvalidate();
1177            }
1178        }
1179        if (!isSwitchingState() && !isInOverscroll) {
1180            ((CellLayout) getChildAt(0)).resetOverscrollTransforms();
1181            ((CellLayout) getChildAt(getChildCount() - 1)).resetOverscrollTransforms();
1182        }
1183        invalidate();
1184    }
1185
1186    private void screenScrolledStandardUI(int screenCenter) {
1187        if (mOverScrollX < 0 || mOverScrollX > mMaxScrollX) {
1188            int index = mOverScrollX < 0 ? 0 : getChildCount() - 1;
1189            CellLayout cl = (CellLayout) getChildAt(index);
1190            float scrollProgress = getScrollProgress(screenCenter, cl, index);
1191            cl.setOverScrollAmount(Math.abs(scrollProgress), index == 0);
1192            float rotation = - WORKSPACE_OVERSCROLL_ROTATION * scrollProgress;
1193            cl.setCameraDistance(mDensity * CAMERA_DISTANCE);
1194            cl.setPivotX(cl.getMeasuredWidth() * (index == 0 ? 0.75f : 0.25f));
1195            cl.setPivotY(cl.getMeasuredHeight() * 0.5f);
1196            cl.setRotationY(rotation);
1197            cl.setOverscrollTransformsDirty(true);
1198            setFadeForOverScroll(Math.abs(scrollProgress));
1199        } else {
1200            if (mOverscrollFade != 0) {
1201                setFadeForOverScroll(0);
1202            }
1203            // We don't want to mess with the translations during transitions
1204            if (!isSwitchingState()) {
1205                ((CellLayout) getChildAt(0)).resetOverscrollTransforms();
1206                ((CellLayout) getChildAt(getChildCount() - 1)).resetOverscrollTransforms();
1207            }
1208        }
1209    }
1210
1211    @Override
1212    protected void screenScrolled(int screenCenter) {
1213        if (LauncherApplication.isScreenLarge()) {
1214            // We don't call super.screenScrolled() here because we handle the adjacent pages alpha
1215            // ourselves (for efficiency), and there are no scrolling indicators to update.
1216            screenScrolledLargeUI(screenCenter);
1217        } else {
1218            super.screenScrolled(screenCenter);
1219            screenScrolledStandardUI(screenCenter);
1220        }
1221    }
1222
1223    @Override
1224    protected void overScroll(float amount) {
1225        if (LauncherApplication.isScreenLarge()) {
1226            dampedOverScroll(amount);
1227        } else {
1228            acceleratedOverScroll(amount);
1229        }
1230    }
1231
1232    protected void onAttachedToWindow() {
1233        super.onAttachedToWindow();
1234        mWindowToken = getWindowToken();
1235        computeScroll();
1236        mDragController.setWindowToken(mWindowToken);
1237    }
1238
1239    protected void onDetachedFromWindow() {
1240        mWindowToken = null;
1241    }
1242
1243    @Override
1244    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
1245        if (mFirstLayout && mCurrentPage >= 0 && mCurrentPage < getChildCount()) {
1246            mUpdateWallpaperOffsetImmediately = true;
1247        }
1248        super.onLayout(changed, left, top, right, bottom);
1249
1250        // if shrinkToBottom() is called on initialization, it has to be deferred
1251        // until after the first call to onLayout so that it has the correct width
1252        if (mSwitchStateAfterFirstLayout) {
1253            mSwitchStateAfterFirstLayout = false;
1254            // shrink can trigger a synchronous onLayout call, so we
1255            // post this to avoid a stack overflow / tangled onLayout calls
1256            post(new Runnable() {
1257                public void run() {
1258                    changeState(mStateAfterFirstLayout, false);
1259                }
1260            });
1261        }
1262    }
1263
1264    @Override
1265    protected void onDraw(Canvas canvas) {
1266        updateWallpaperOffsets();
1267
1268        // Draw the background gradient if necessary
1269        if (mBackground != null && mBackgroundAlpha > 0.0f && mDrawBackground) {
1270            int alpha = (int) (mBackgroundAlpha * 255);
1271            mBackground.setAlpha(alpha);
1272            mBackground.setBounds(mScrollX, 0, mScrollX + getMeasuredWidth(),
1273                    getMeasuredHeight());
1274            mBackground.draw(canvas);
1275        }
1276
1277        super.onDraw(canvas);
1278    }
1279
1280    boolean isDrawingBackgroundGradient() {
1281        return (mBackground != null && mBackgroundAlpha > 0.0f && mDrawBackground);
1282    }
1283
1284    public void scrollTo (int x, int y) {
1285        super.scrollTo(x, y);
1286        syncChildrenLayersEnabledOnVisiblePages();
1287    }
1288
1289    // This method just applies the value mChildrenLayersEnabled to all the pages that
1290    // will be rendered on the next frame.
1291    // We do this because calling setChildrenLayersEnabled on a view that's not
1292    // visible/rendered causes slowdowns on some graphics cards
1293    private void syncChildrenLayersEnabledOnVisiblePages() {
1294        if (mChildrenLayersEnabled) {
1295            getVisiblePages(mTempVisiblePagesRange);
1296            final int leftScreen = mTempVisiblePagesRange[0];
1297            final int rightScreen = mTempVisiblePagesRange[1];
1298            if (leftScreen != -1 && rightScreen != -1) {
1299                for (int i = leftScreen; i <= rightScreen; i++) {
1300                    ViewGroup page = (ViewGroup) getPageAt(i);
1301                    if (page.getVisibility() == VISIBLE &&
1302                            page.getAlpha() > ViewConfiguration.ALPHA_THRESHOLD) {
1303                        ((ViewGroup)getPageAt(i)).setChildrenLayersEnabled(true);
1304                    }
1305                }
1306            }
1307        }
1308    }
1309
1310    @Override
1311    protected void dispatchDraw(Canvas canvas) {
1312        super.dispatchDraw(canvas);
1313
1314        if (mInScrollArea && !LauncherApplication.isScreenLarge()) {
1315            final int width = getWidth();
1316            final int height = getHeight();
1317            final int pageHeight = getChildAt(0).getHeight();
1318
1319            // Set the height of the outline to be the height of the page
1320            final int offset = (height - pageHeight - mPaddingTop - mPaddingBottom) / 2;
1321            final int paddingTop = mPaddingTop + offset;
1322            final int paddingBottom = mPaddingBottom + offset;
1323
1324            final CellLayout leftPage = (CellLayout) getChildAt(mCurrentPage - 1);
1325            final CellLayout rightPage = (CellLayout) getChildAt(mCurrentPage + 1);
1326
1327            if (leftPage != null && leftPage.getIsDragOverlapping()) {
1328                final Drawable d = getResources().getDrawable(R.drawable.page_hover_left_holo);
1329                d.setBounds(mScrollX, paddingTop, mScrollX + d.getIntrinsicWidth(),
1330                        height - paddingBottom);
1331                d.draw(canvas);
1332            } else if (rightPage != null && rightPage.getIsDragOverlapping()) {
1333                final Drawable d = getResources().getDrawable(R.drawable.page_hover_right_holo);
1334                d.setBounds(mScrollX + width - d.getIntrinsicWidth(), paddingTop, mScrollX + width,
1335                        height - paddingBottom);
1336                d.draw(canvas);
1337            }
1338        }
1339    }
1340
1341    @Override
1342    protected boolean onRequestFocusInDescendants(int direction, Rect previouslyFocusedRect) {
1343        if (!mLauncher.isAllAppsVisible()) {
1344            final Folder openFolder = getOpenFolder();
1345            if (openFolder != null) {
1346                return openFolder.requestFocus(direction, previouslyFocusedRect);
1347            } else {
1348                return super.onRequestFocusInDescendants(direction, previouslyFocusedRect);
1349            }
1350        }
1351        return false;
1352    }
1353
1354    @Override
1355    public int getDescendantFocusability() {
1356        if (isSmall()) {
1357            return ViewGroup.FOCUS_BLOCK_DESCENDANTS;
1358        }
1359        return super.getDescendantFocusability();
1360    }
1361
1362    @Override
1363    public void addFocusables(ArrayList<View> views, int direction, int focusableMode) {
1364        if (!mLauncher.isAllAppsVisible()) {
1365            final Folder openFolder = getOpenFolder();
1366            if (openFolder != null) {
1367                openFolder.addFocusables(views, direction);
1368            } else {
1369                super.addFocusables(views, direction, focusableMode);
1370            }
1371        }
1372    }
1373
1374    public boolean isSmall() {
1375        return mState == State.SMALL || mState == State.SPRING_LOADED;
1376    }
1377
1378    void enableChildrenCache(int fromPage, int toPage) {
1379        if (fromPage > toPage) {
1380            final int temp = fromPage;
1381            fromPage = toPage;
1382            toPage = temp;
1383        }
1384
1385        final int screenCount = getChildCount();
1386
1387        fromPage = Math.max(fromPage, 0);
1388        toPage = Math.min(toPage, screenCount - 1);
1389
1390        for (int i = fromPage; i <= toPage; i++) {
1391            final CellLayout layout = (CellLayout) getChildAt(i);
1392            layout.setChildrenDrawnWithCacheEnabled(true);
1393            layout.setChildrenDrawingCacheEnabled(true);
1394        }
1395    }
1396
1397    void clearChildrenCache() {
1398        final int screenCount = getChildCount();
1399        for (int i = 0; i < screenCount; i++) {
1400            final CellLayout layout = (CellLayout) getChildAt(i);
1401            layout.setChildrenDrawnWithCacheEnabled(false);
1402            // In software mode, we don't want the items to continue to be drawn into bitmaps
1403            if (!isHardwareAccelerated()) {
1404                layout.setChildrenDrawingCacheEnabled(false);
1405            }
1406        }
1407    }
1408
1409    private void updateChildrenLayersEnabled() {
1410        boolean small = isSmall() || mIsSwitchingState;
1411        boolean dragging = mAnimatingViewIntoPlace || mIsDragOccuring;
1412        boolean enableChildrenLayers = small || dragging || isPageMoving();
1413
1414        if (enableChildrenLayers != mChildrenLayersEnabled) {
1415            mChildrenLayersEnabled = enableChildrenLayers;
1416            // calling setChildrenLayersEnabled on a view that's not visible/rendered
1417            // causes slowdowns on some graphics cards, so we only disable it here and leave
1418            // the enabling to dispatchDraw
1419            if (!enableChildrenLayers) {
1420                for (int i = 0; i < getPageCount(); i++) {
1421                    ((ViewGroup)getChildAt(i)).setChildrenLayersEnabled(false);
1422                }
1423            }
1424        }
1425    }
1426
1427    protected void onWallpaperTap(MotionEvent ev) {
1428        final int[] position = mTempCell;
1429        getLocationOnScreen(position);
1430
1431        int pointerIndex = ev.getActionIndex();
1432        position[0] += (int) ev.getX(pointerIndex);
1433        position[1] += (int) ev.getY(pointerIndex);
1434
1435        mWallpaperManager.sendWallpaperCommand(getWindowToken(),
1436                ev.getAction() == MotionEvent.ACTION_UP
1437                        ? WallpaperManager.COMMAND_TAP : WallpaperManager.COMMAND_SECONDARY_TAP,
1438                position[0], position[1], 0, null);
1439    }
1440
1441    /*
1442     * This interpolator emulates the rate at which the perceived scale of an object changes
1443     * as its distance from a camera increases. When this interpolator is applied to a scale
1444     * animation on a view, it evokes the sense that the object is shrinking due to moving away
1445     * from the camera.
1446     */
1447    static class ZInterpolator implements TimeInterpolator {
1448        private float focalLength;
1449
1450        public ZInterpolator(float foc) {
1451            focalLength = foc;
1452        }
1453
1454        public float getInterpolation(float input) {
1455            return (1.0f - focalLength / (focalLength + input)) /
1456                (1.0f - focalLength / (focalLength + 1.0f));
1457        }
1458    }
1459
1460    /*
1461     * The exact reverse of ZInterpolator.
1462     */
1463    static class InverseZInterpolator implements TimeInterpolator {
1464        private ZInterpolator zInterpolator;
1465        public InverseZInterpolator(float foc) {
1466            zInterpolator = new ZInterpolator(foc);
1467        }
1468        public float getInterpolation(float input) {
1469            return 1 - zInterpolator.getInterpolation(1 - input);
1470        }
1471    }
1472
1473    /*
1474     * ZInterpolator compounded with an ease-out.
1475     */
1476    static class ZoomOutInterpolator implements TimeInterpolator {
1477        private final DecelerateInterpolator decelerate = new DecelerateInterpolator(0.75f);
1478        private final ZInterpolator zInterpolator = new ZInterpolator(0.13f);
1479
1480        public float getInterpolation(float input) {
1481            return decelerate.getInterpolation(zInterpolator.getInterpolation(input));
1482        }
1483    }
1484
1485    /*
1486     * InvereZInterpolator compounded with an ease-out.
1487     */
1488    static class ZoomInInterpolator implements TimeInterpolator {
1489        private final InverseZInterpolator inverseZInterpolator = new InverseZInterpolator(0.35f);
1490        private final DecelerateInterpolator decelerate = new DecelerateInterpolator(3.0f);
1491
1492        public float getInterpolation(float input) {
1493            return decelerate.getInterpolation(inverseZInterpolator.getInterpolation(input));
1494        }
1495    }
1496
1497    private final ZoomInInterpolator mZoomInInterpolator = new ZoomInInterpolator();
1498
1499    /*
1500    *
1501    * We call these methods (onDragStartedWithItemSpans/onDragStartedWithSize) whenever we
1502    * start a drag in Launcher, regardless of whether the drag has ever entered the Workspace
1503    *
1504    * These methods mark the appropriate pages as accepting drops (which alters their visual
1505    * appearance).
1506    *
1507    */
1508    public void onDragStartedWithItem(View v) {
1509        final Canvas canvas = new Canvas();
1510
1511        // We need to add extra padding to the bitmap to make room for the glow effect
1512        final int bitmapPadding = HolographicOutlineHelper.MAX_OUTER_BLUR_RADIUS;
1513
1514        // The outline is used to visualize where the item will land if dropped
1515        mDragOutline = createDragOutline(v, canvas, bitmapPadding);
1516    }
1517
1518    public void onDragStartedWithItem(PendingAddItemInfo info, Bitmap b, Paint alphaClipPaint) {
1519        final Canvas canvas = new Canvas();
1520
1521        // We need to add extra padding to the bitmap to make room for the glow effect
1522        final int bitmapPadding = HolographicOutlineHelper.MAX_OUTER_BLUR_RADIUS;
1523
1524        CellLayout cl = (CellLayout) getChildAt(0);
1525
1526        int[] size = estimateItemSize(info.spanX, info.spanY, info, false);
1527
1528        // The outline is used to visualize where the item will land if dropped
1529        mDragOutline = createDragOutline(b, canvas, bitmapPadding, size[0], size[1], alphaClipPaint);
1530    }
1531
1532    // we call this method whenever a drag and drop in Launcher finishes, even if Workspace was
1533    // never dragged over
1534    public void onDragStopped(boolean success) {
1535        // In the success case, DragController has already called onDragExit()
1536        if (!success) {
1537            doDragExit(null);
1538        }
1539    }
1540
1541    public void exitWidgetResizeMode() {
1542        DragLayer dragLayer = mLauncher.getDragLayer();
1543        dragLayer.clearAllResizeFrames();
1544    }
1545
1546    private void initAnimationArrays() {
1547        final int childCount = getChildCount();
1548        if (mOldTranslationXs != null) return;
1549        mOldTranslationXs = new float[childCount];
1550        mOldTranslationYs = new float[childCount];
1551        mOldScaleXs = new float[childCount];
1552        mOldScaleYs = new float[childCount];
1553        mOldBackgroundAlphas = new float[childCount];
1554        mOldBackgroundAlphaMultipliers = new float[childCount];
1555        mOldAlphas = new float[childCount];
1556        mOldRotationYs = new float[childCount];
1557        mNewTranslationXs = new float[childCount];
1558        mNewTranslationYs = new float[childCount];
1559        mNewScaleXs = new float[childCount];
1560        mNewScaleYs = new float[childCount];
1561        mNewBackgroundAlphas = new float[childCount];
1562        mNewBackgroundAlphaMultipliers = new float[childCount];
1563        mNewAlphas = new float[childCount];
1564        mNewRotationYs = new float[childCount];
1565    }
1566
1567    public void changeState(State shrinkState) {
1568        changeState(shrinkState, true);
1569    }
1570
1571    void changeState(final State state, boolean animated) {
1572        changeState(state, animated, 0);
1573    }
1574
1575    void changeState(final State state, boolean animated, int delay) {
1576        if (mState == state) {
1577            return;
1578        }
1579        if (mFirstLayout) {
1580            // (mFirstLayout == "first layout has not happened yet")
1581            // cancel any pending shrinks that were set earlier
1582            mSwitchStateAfterFirstLayout = false;
1583            mStateAfterFirstLayout = state;
1584            return;
1585        }
1586
1587        // Initialize animation arrays for the first time if necessary
1588        initAnimationArrays();
1589
1590        // Cancel any running transition animations
1591        if (mAnimator != null) mAnimator.cancel();
1592        mAnimator = new AnimatorSet();
1593
1594        // Stop any scrolling, move to the current page right away
1595        setCurrentPage((mNextPage != INVALID_PAGE) ? mNextPage : mCurrentPage);
1596
1597        final State oldState = mState;
1598        final boolean oldStateIsNormal = (oldState == State.NORMAL);
1599        final boolean oldStateIsSmall = (oldState == State.SMALL);
1600        mState = state;
1601        final boolean stateIsNormal = (state == State.NORMAL);
1602        final boolean stateIsSpringLoaded = (state == State.SPRING_LOADED);
1603        final boolean stateIsSmall = (state == State.SMALL);
1604        float finalScaleFactor = 1.0f;
1605        float finalBackgroundAlpha = stateIsSpringLoaded ? 1.0f : 0f;
1606        float translationX = 0;
1607        float translationY = 0;
1608        boolean zoomIn = true;
1609
1610        if (state != State.NORMAL) {
1611            finalScaleFactor = mSpringLoadedShrinkFactor - (stateIsSmall ? 0.1f : 0);
1612            if (oldStateIsNormal && stateIsSmall) {
1613                zoomIn = false;
1614                setLayoutScale(finalScaleFactor);
1615                updateChildrenLayersEnabled();
1616            } else {
1617                finalBackgroundAlpha = 1.0f;
1618                setLayoutScale(finalScaleFactor);
1619            }
1620        } else {
1621            setLayoutScale(1.0f);
1622        }
1623
1624        final int duration = zoomIn ?
1625                getResources().getInteger(R.integer.config_workspaceUnshrinkTime) :
1626                getResources().getInteger(R.integer.config_appsCustomizeWorkspaceShrinkTime);
1627        for (int i = 0; i < getChildCount(); i++) {
1628            final CellLayout cl = (CellLayout) getChildAt(i);
1629            float rotation = 0f;
1630            float initialAlpha = cl.getAlpha();
1631            float finalAlphaMultiplierValue = 1f;
1632            float finalAlpha = (!mFadeInAdjacentScreens || stateIsSpringLoaded ||
1633                    (i == mCurrentPage)) ? 1f : 0f;
1634
1635            // Determine the pages alpha during the state transition
1636            if ((oldStateIsSmall && stateIsNormal) ||
1637                (oldStateIsNormal && stateIsSmall)) {
1638                // To/from workspace - only show the current page unless the transition is not
1639                //                     animated and the animation end callback below doesn't run
1640                if (i == mCurrentPage || !animated) {
1641                    finalAlpha = 1f;
1642                    finalAlphaMultiplierValue = 0f;
1643                } else {
1644                    initialAlpha = 0f;
1645                    finalAlpha = 0f;
1646                }
1647            }
1648
1649            // Update the rotation of the screen (don't apply rotation on Phone UI)
1650            if (LauncherApplication.isScreenLarge()) {
1651                if (i < mCurrentPage) {
1652                    rotation = WORKSPACE_ROTATION;
1653                } else if (i > mCurrentPage) {
1654                    rotation = -WORKSPACE_ROTATION;
1655                }
1656            }
1657
1658            // If the screen is not xlarge, then don't rotate the CellLayouts
1659            // NOTE: If we don't update the side pages alpha, then we should not hide the side
1660            //       pages. see unshrink().
1661            if (LauncherApplication.isScreenLarge()) {
1662                translationX = getOffsetXForRotation(rotation, cl.getWidth(), cl.getHeight());
1663            }
1664
1665            mOldAlphas[i] = initialAlpha;
1666            mNewAlphas[i] = finalAlpha;
1667            if (animated) {
1668                mOldTranslationXs[i] = cl.getTranslationX();
1669                mOldTranslationYs[i] = cl.getTranslationY();
1670                mOldScaleXs[i] = cl.getScaleX();
1671                mOldScaleYs[i] = cl.getScaleY();
1672                mOldBackgroundAlphas[i] = cl.getBackgroundAlpha();
1673                mOldBackgroundAlphaMultipliers[i] = cl.getBackgroundAlphaMultiplier();
1674                mOldRotationYs[i] = cl.getRotationY();
1675
1676                mNewTranslationXs[i] = translationX;
1677                mNewTranslationYs[i] = translationY;
1678                mNewScaleXs[i] = finalScaleFactor;
1679                mNewScaleYs[i] = finalScaleFactor;
1680                mNewBackgroundAlphas[i] = finalBackgroundAlpha;
1681                mNewBackgroundAlphaMultipliers[i] = finalAlphaMultiplierValue;
1682                mNewRotationYs[i] = rotation;
1683            } else {
1684                cl.setTranslationX(translationX);
1685                cl.setTranslationY(translationY);
1686                cl.setScaleX(finalScaleFactor);
1687                cl.setScaleY(finalScaleFactor);
1688                cl.setBackgroundAlpha(finalBackgroundAlpha);
1689                cl.setBackgroundAlphaMultiplier(finalAlphaMultiplierValue);
1690                cl.setAlpha(finalAlpha);
1691                cl.setRotationY(rotation);
1692                mChangeStateAnimationListener.onAnimationEnd(null);
1693            }
1694        }
1695
1696        if (animated) {
1697            ValueAnimator animWithInterpolator =
1698                ValueAnimator.ofFloat(0f, 1f).setDuration(duration);
1699
1700            if (zoomIn) {
1701                animWithInterpolator.setInterpolator(mZoomInInterpolator);
1702            }
1703
1704            animWithInterpolator.addListener(new AnimatorListenerAdapter() {
1705                @Override
1706                public void onAnimationEnd(android.animation.Animator animation) {
1707                    // The above code to determine initialAlpha and finalAlpha will ensure that only
1708                    // the current page is visible during (and subsequently, after) the transition
1709                    // animation.  If fade adjacent pages is disabled, then re-enable the page
1710                    // visibility after the transition animation.
1711                    if (!mFadeInAdjacentScreens && stateIsNormal && oldStateIsSmall) {
1712                        for (int i = 0; i < getChildCount(); i++) {
1713                            final CellLayout cl = (CellLayout) getChildAt(i);
1714                            cl.setAlpha(1f);
1715                        }
1716                    }
1717                }
1718            });
1719            animWithInterpolator.addUpdateListener(new LauncherAnimatorUpdateListener() {
1720                public void onAnimationUpdate(float a, float b) {
1721                    mTransitionProgress = b;
1722                    if (b == 0f) {
1723                        // an optimization, but not required
1724                        return;
1725                    }
1726                    invalidate();
1727                    for (int i = 0; i < getChildCount(); i++) {
1728                        final CellLayout cl = (CellLayout) getChildAt(i);
1729                        cl.fastInvalidate();
1730                        cl.setFastTranslationX(a * mOldTranslationXs[i] + b * mNewTranslationXs[i]);
1731                        cl.setFastTranslationY(a * mOldTranslationYs[i] + b * mNewTranslationYs[i]);
1732                        cl.setFastScaleX(a * mOldScaleXs[i] + b * mNewScaleXs[i]);
1733                        cl.setFastScaleY(a * mOldScaleYs[i] + b * mNewScaleYs[i]);
1734                        cl.setFastBackgroundAlpha(
1735                                a * mOldBackgroundAlphas[i] + b * mNewBackgroundAlphas[i]);
1736                        cl.setBackgroundAlphaMultiplier(a * mOldBackgroundAlphaMultipliers[i] +
1737                                b * mNewBackgroundAlphaMultipliers[i]);
1738                        cl.setFastAlpha(a * mOldAlphas[i] + b * mNewAlphas[i]);
1739                    }
1740                    syncChildrenLayersEnabledOnVisiblePages();
1741                }
1742            });
1743
1744            ValueAnimator rotationAnim =
1745                ValueAnimator.ofFloat(0f, 1f).setDuration(duration);
1746            rotationAnim.setInterpolator(new DecelerateInterpolator(2.0f));
1747            rotationAnim.addUpdateListener(new LauncherAnimatorUpdateListener() {
1748                public void onAnimationUpdate(float a, float b) {
1749                    if (b == 0f) {
1750                        // an optimization, but not required
1751                        return;
1752                    }
1753                    for (int i = 0; i < getChildCount(); i++) {
1754                        final CellLayout cl = (CellLayout) getChildAt(i);
1755                        cl.setFastRotationY(a * mOldRotationYs[i] + b * mNewRotationYs[i]);
1756                    }
1757                }
1758            });
1759
1760            mAnimator.playTogether(animWithInterpolator, rotationAnim);
1761            mAnimator.setStartDelay(delay);
1762            // If we call this when we're not animated, onAnimationEnd is never called on
1763            // the listener; make sure we only use the listener when we're actually animating
1764            mAnimator.addListener(mChangeStateAnimationListener);
1765            mAnimator.start();
1766        }
1767
1768        if (stateIsSpringLoaded) {
1769            // Right now we're covered by Apps Customize
1770            // Show the background gradient immediately, so the gradient will
1771            // be showing once AppsCustomize disappears
1772            animateBackgroundGradient(getResources().getInteger(
1773                    R.integer.config_appsCustomizeSpringLoadedBgAlpha) / 100f, false);
1774        } else {
1775            // Fade the background gradient away
1776            animateBackgroundGradient(0f, true);
1777        }
1778        syncChildrenLayersEnabledOnVisiblePages();
1779    }
1780
1781    /**
1782     * Draw the View v into the given Canvas.
1783     *
1784     * @param v the view to draw
1785     * @param destCanvas the canvas to draw on
1786     * @param padding the horizontal and vertical padding to use when drawing
1787     */
1788    private void drawDragView(View v, Canvas destCanvas, int padding, boolean pruneToDrawable) {
1789        final Rect clipRect = mTempRect;
1790        v.getDrawingRect(clipRect);
1791
1792        boolean textVisible = false;
1793
1794        destCanvas.save();
1795        if (v instanceof TextView && pruneToDrawable) {
1796            Drawable d = ((TextView) v).getCompoundDrawables()[1];
1797            clipRect.set(0, 0, d.getIntrinsicWidth() + padding, d.getIntrinsicHeight() + padding);
1798            destCanvas.translate(padding / 2, padding / 2);
1799            d.draw(destCanvas);
1800        } else {
1801            if (v instanceof FolderIcon) {
1802                // For FolderIcons the text can bleed into the icon area, and so we need to
1803                // hide the text completely (which can't be achieved by clipping).
1804                if (((FolderIcon) v).getTextVisible()) {
1805                    ((FolderIcon) v).setTextVisible(false);
1806                    textVisible = true;
1807                }
1808            } else if (v instanceof BubbleTextView) {
1809                final BubbleTextView tv = (BubbleTextView) v;
1810                clipRect.bottom = tv.getExtendedPaddingTop() - (int) BubbleTextView.PADDING_V +
1811                        tv.getLayout().getLineTop(0);
1812            } else if (v instanceof TextView) {
1813                final TextView tv = (TextView) v;
1814                clipRect.bottom = tv.getExtendedPaddingTop() - tv.getCompoundDrawablePadding() +
1815                        tv.getLayout().getLineTop(0);
1816            }
1817            destCanvas.translate(-v.getScrollX() + padding / 2, -v.getScrollY() + padding / 2);
1818            destCanvas.clipRect(clipRect, Op.REPLACE);
1819            v.draw(destCanvas);
1820
1821            // Restore text visibility of FolderIcon if necessary
1822            if (textVisible) {
1823                ((FolderIcon) v).setTextVisible(true);
1824            }
1825        }
1826        destCanvas.restore();
1827    }
1828
1829    /**
1830     * Returns a new bitmap to show when the given View is being dragged around.
1831     * Responsibility for the bitmap is transferred to the caller.
1832     */
1833    public Bitmap createDragBitmap(View v, Canvas canvas, int padding) {
1834        final int outlineColor = getResources().getColor(android.R.color.holo_blue_light);
1835        Bitmap b;
1836
1837        if (v instanceof TextView) {
1838            Drawable d = ((TextView) v).getCompoundDrawables()[1];
1839            b = Bitmap.createBitmap(d.getIntrinsicWidth() + padding,
1840                    d.getIntrinsicHeight() + padding, Bitmap.Config.ARGB_8888);
1841        } else {
1842            b = Bitmap.createBitmap(
1843                    v.getWidth() + padding, v.getHeight() + padding, Bitmap.Config.ARGB_8888);
1844        }
1845
1846        canvas.setBitmap(b);
1847        drawDragView(v, canvas, padding, true);
1848        mOutlineHelper.applyOuterBlur(b, canvas, outlineColor);
1849        canvas.drawColor(mDragViewMultiplyColor, PorterDuff.Mode.MULTIPLY);
1850        canvas.setBitmap(null);
1851
1852        return b;
1853    }
1854
1855    /**
1856     * Returns a new bitmap to be used as the object outline, e.g. to visualize the drop location.
1857     * Responsibility for the bitmap is transferred to the caller.
1858     */
1859    private Bitmap createDragOutline(View v, Canvas canvas, int padding) {
1860        final int outlineColor = getResources().getColor(android.R.color.holo_blue_light);
1861        final Bitmap b = Bitmap.createBitmap(
1862                v.getWidth() + padding, v.getHeight() + padding, Bitmap.Config.ARGB_8888);
1863
1864        canvas.setBitmap(b);
1865        drawDragView(v, canvas, padding, true);
1866        mOutlineHelper.applyMediumExpensiveOutlineWithBlur(b, canvas, outlineColor, outlineColor);
1867        canvas.setBitmap(null);
1868        return b;
1869    }
1870
1871    /**
1872     * Returns a new bitmap to be used as the object outline, e.g. to visualize the drop location.
1873     * Responsibility for the bitmap is transferred to the caller.
1874     */
1875    private Bitmap createDragOutline(Bitmap orig, Canvas canvas, int padding, int w, int h) {
1876        return createDragOutline(orig, canvas, padding, w, h, null);
1877    }
1878    private Bitmap createDragOutline(Bitmap orig, Canvas canvas, int padding, int w, int h,
1879            Paint alphaClipPaint) {
1880        final int outlineColor = getResources().getColor(android.R.color.holo_blue_light);
1881        final Bitmap b = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
1882        canvas.setBitmap(b);
1883
1884        Rect src = new Rect(0, 0, orig.getWidth(), orig.getHeight());
1885        float scaleFactor = Math.min((w - padding) / (float) orig.getWidth(),
1886                (h - padding) / (float) orig.getHeight());
1887        int scaledWidth = (int) (scaleFactor * orig.getWidth());
1888        int scaledHeight = (int) (scaleFactor * orig.getHeight());
1889        Rect dst = new Rect(0, 0, scaledWidth, scaledHeight);
1890
1891        // center the image
1892        dst.offset((w - scaledWidth) / 2, (h - scaledHeight) / 2);
1893
1894        Paint p = new Paint();
1895        p.setFilterBitmap(true);
1896        canvas.drawBitmap(orig, src, dst, p);
1897        mOutlineHelper.applyMediumExpensiveOutlineWithBlur(b, canvas, outlineColor, outlineColor,
1898                alphaClipPaint);
1899        canvas.setBitmap(null);
1900
1901        return b;
1902    }
1903
1904    /**
1905     * Creates a drag outline to represent a drop (that we don't have the actual information for
1906     * yet).  May be changed in the future to alter the drop outline slightly depending on the
1907     * clip description mime data.
1908     */
1909    private Bitmap createExternalDragOutline(Canvas canvas, int padding) {
1910        Resources r = getResources();
1911        final int outlineColor = r.getColor(android.R.color.holo_blue_light);
1912        final int iconWidth = r.getDimensionPixelSize(R.dimen.workspace_cell_width);
1913        final int iconHeight = r.getDimensionPixelSize(R.dimen.workspace_cell_height);
1914        final int rectRadius = r.getDimensionPixelSize(R.dimen.external_drop_icon_rect_radius);
1915        final int inset = (int) (Math.min(iconWidth, iconHeight) * 0.2f);
1916        final Bitmap b = Bitmap.createBitmap(
1917                iconWidth + padding, iconHeight + padding, Bitmap.Config.ARGB_8888);
1918
1919        canvas.setBitmap(b);
1920        canvas.drawRoundRect(new RectF(inset, inset, iconWidth - inset, iconHeight - inset),
1921                rectRadius, rectRadius, mExternalDragOutlinePaint);
1922        mOutlineHelper.applyMediumExpensiveOutlineWithBlur(b, canvas, outlineColor, outlineColor);
1923        canvas.setBitmap(null);
1924        return b;
1925    }
1926
1927    void startDrag(CellLayout.CellInfo cellInfo) {
1928        View child = cellInfo.cell;
1929
1930        // Make sure the drag was started by a long press as opposed to a long click.
1931        if (!child.isInTouchMode()) {
1932            return;
1933        }
1934
1935        mDragInfo = cellInfo;
1936        child.setVisibility(GONE);
1937
1938        child.clearFocus();
1939        child.setPressed(false);
1940
1941        final Canvas canvas = new Canvas();
1942
1943        // We need to add extra padding to the bitmap to make room for the glow effect
1944        final int bitmapPadding = HolographicOutlineHelper.MAX_OUTER_BLUR_RADIUS;
1945
1946        // The outline is used to visualize where the item will land if dropped
1947        mDragOutline = createDragOutline(child, canvas, bitmapPadding);
1948        beginDragShared(child, this);
1949    }
1950
1951    public void beginDragShared(View child, DragSource source) {
1952        Resources r = getResources();
1953
1954        // We need to add extra padding to the bitmap to make room for the glow effect
1955        final int bitmapPadding = HolographicOutlineHelper.MAX_OUTER_BLUR_RADIUS;
1956
1957        // The drag bitmap follows the touch point around on the screen
1958        final Bitmap b = createDragBitmap(child, new Canvas(), bitmapPadding);
1959
1960        final int bmpWidth = b.getWidth();
1961
1962        mLauncher.getDragLayer().getLocationInDragLayer(child, mTempXY);
1963        final int dragLayerX = (int) mTempXY[0] + (child.getWidth() - bmpWidth) / 2;
1964        int dragLayerY = mTempXY[1] - bitmapPadding / 2;
1965
1966        Point dragVisualizeOffset = null;
1967        Rect dragRect = null;
1968        if (child instanceof BubbleTextView || child instanceof PagedViewIcon) {
1969            int iconSize = r.getDimensionPixelSize(R.dimen.app_icon_size);
1970            int iconPaddingTop = r.getDimensionPixelSize(R.dimen.app_icon_padding_top);
1971            int top = child.getPaddingTop();
1972            int left = (bmpWidth - iconSize) / 2;
1973            int right = left + iconSize;
1974            int bottom = top + iconSize;
1975            dragLayerY += top;
1976            // Note: The drag region is used to calculate drag layer offsets, but the
1977            // dragVisualizeOffset in addition to the dragRect (the size) to position the outline.
1978            dragVisualizeOffset = new Point(-bitmapPadding / 2, iconPaddingTop - bitmapPadding / 2);
1979            dragRect = new Rect(left, top, right, bottom);
1980        } else if (child instanceof FolderIcon) {
1981            int previewSize = r.getDimensionPixelSize(R.dimen.folder_preview_size);
1982            dragRect = new Rect(0, 0, child.getWidth(), previewSize);
1983        }
1984
1985        // Clear the pressed state if necessary
1986        if (child instanceof BubbleTextView) {
1987            BubbleTextView icon = (BubbleTextView) child;
1988            icon.clearPressedOrFocusedBackground();
1989        }
1990
1991        mDragController.startDrag(b, dragLayerX, dragLayerY, source, child.getTag(),
1992                DragController.DRAG_ACTION_MOVE, dragVisualizeOffset, dragRect);
1993        b.recycle();
1994    }
1995
1996    void addApplicationShortcut(ShortcutInfo info, CellLayout target, long container, int screen,
1997            int cellX, int cellY, boolean insertAtFirst, int intersectX, int intersectY) {
1998        View view = mLauncher.createShortcut(R.layout.application, target, (ShortcutInfo) info);
1999
2000        final int[] cellXY = new int[2];
2001        target.findCellForSpanThatIntersects(cellXY, 1, 1, intersectX, intersectY);
2002        addInScreen(view, container, screen, cellXY[0], cellXY[1], 1, 1, insertAtFirst);
2003        LauncherModel.addOrMoveItemInDatabase(mLauncher, info, container, screen, cellXY[0],
2004                cellXY[1]);
2005    }
2006
2007    public boolean transitionStateShouldAllowDrop() {
2008        return (!isSwitchingState() || mTransitionProgress > 0.5f);
2009    }
2010
2011    /**
2012     * {@inheritDoc}
2013     */
2014    public boolean acceptDrop(DragObject d) {
2015        // If it's an external drop (e.g. from All Apps), check if it should be accepted
2016        if (d.dragSource != this) {
2017            // Don't accept the drop if we're not over a screen at time of drop
2018            if (mDragTargetLayout == null) {
2019                return false;
2020            }
2021            if (!transitionStateShouldAllowDrop()) return false;
2022
2023            mDragViewVisualCenter = getDragViewVisualCenter(d.x, d.y, d.xOffset, d.yOffset,
2024                    d.dragView, mDragViewVisualCenter);
2025
2026            // We want the point to be mapped to the dragTarget.
2027            if (mLauncher.isHotseatLayout(mDragTargetLayout)) {
2028                mapPointFromSelfToSibling(mLauncher.getHotseat(), mDragViewVisualCenter);
2029            } else {
2030                mapPointFromSelfToChild(mDragTargetLayout, mDragViewVisualCenter, null);
2031            }
2032
2033            int spanX = 1;
2034            int spanY = 1;
2035            View ignoreView = null;
2036            if (mDragInfo != null) {
2037                final CellLayout.CellInfo dragCellInfo = mDragInfo;
2038                spanX = dragCellInfo.spanX;
2039                spanY = dragCellInfo.spanY;
2040                ignoreView = dragCellInfo.cell;
2041            } else {
2042                final ItemInfo dragInfo = (ItemInfo) d.dragInfo;
2043                spanX = dragInfo.spanX;
2044                spanY = dragInfo.spanY;
2045            }
2046
2047            mTargetCell = findNearestArea((int) mDragViewVisualCenter[0],
2048                    (int) mDragViewVisualCenter[1], spanX, spanY, mDragTargetLayout, mTargetCell);
2049            if (willCreateUserFolder((ItemInfo) d.dragInfo, mDragTargetLayout, mTargetCell, true)) {
2050                return true;
2051            }
2052            if (willAddToExistingUserFolder((ItemInfo) d.dragInfo, mDragTargetLayout,
2053                    mTargetCell)) {
2054                return true;
2055            }
2056
2057
2058            // Don't accept the drop if there's no room for the item
2059            if (!mDragTargetLayout.findCellForSpanIgnoring(null, spanX, spanY, ignoreView)) {
2060                mLauncher.showOutOfSpaceMessage();
2061                return false;
2062            }
2063        }
2064        return true;
2065    }
2066
2067    boolean willCreateUserFolder(ItemInfo info, CellLayout target, int[] targetCell,
2068            boolean considerTimeout) {
2069        View dropOverView = target.getChildAt(targetCell[0], targetCell[1]);
2070
2071        boolean hasntMoved = false;
2072        if (mDragInfo != null) {
2073            CellLayout cellParent = getParentCellLayoutForView(mDragInfo.cell);
2074            hasntMoved = (mDragInfo.cellX == targetCell[0] &&
2075                    mDragInfo.cellY == targetCell[1]) && (cellParent == target);
2076        }
2077
2078        if (dropOverView == null || hasntMoved || (considerTimeout && !mCreateUserFolderOnDrop)) {
2079            return false;
2080        }
2081
2082        boolean aboveShortcut = (dropOverView.getTag() instanceof ShortcutInfo);
2083        boolean willBecomeShortcut =
2084                (info.itemType == LauncherSettings.Favorites.ITEM_TYPE_APPLICATION ||
2085                info.itemType == LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT);
2086
2087        return (aboveShortcut && willBecomeShortcut);
2088    }
2089
2090    boolean willAddToExistingUserFolder(Object dragInfo, CellLayout target, int[] targetCell) {
2091        View dropOverView = target.getChildAt(targetCell[0], targetCell[1]);
2092        if (dropOverView instanceof FolderIcon) {
2093            FolderIcon fi = (FolderIcon) dropOverView;
2094            if (fi.acceptDrop(dragInfo)) {
2095                return true;
2096            }
2097        }
2098        return false;
2099    }
2100
2101    boolean createUserFolderIfNecessary(View newView, long container, CellLayout target,
2102            int[] targetCell, boolean external, DragView dragView, Runnable postAnimationRunnable) {
2103        View v = target.getChildAt(targetCell[0], targetCell[1]);
2104        boolean hasntMoved = false;
2105        if (mDragInfo != null) {
2106            CellLayout cellParent = getParentCellLayoutForView(mDragInfo.cell);
2107            hasntMoved = (mDragInfo.cellX == targetCell[0] &&
2108                    mDragInfo.cellY == targetCell[1]) && (cellParent == target);
2109        }
2110
2111        if (v == null || hasntMoved || !mCreateUserFolderOnDrop) return false;
2112        mCreateUserFolderOnDrop = false;
2113        final int screen = (targetCell == null) ? mDragInfo.screen : indexOfChild(target);
2114
2115        boolean aboveShortcut = (v.getTag() instanceof ShortcutInfo);
2116        boolean willBecomeShortcut = (newView.getTag() instanceof ShortcutInfo);
2117
2118        if (aboveShortcut && willBecomeShortcut) {
2119            ShortcutInfo sourceInfo = (ShortcutInfo) newView.getTag();
2120            ShortcutInfo destInfo = (ShortcutInfo) v.getTag();
2121            // if the drag started here, we need to remove it from the workspace
2122            if (!external) {
2123                getParentCellLayoutForView(mDragInfo.cell).removeView(mDragInfo.cell);
2124            }
2125
2126            Rect folderLocation = new Rect();
2127            float scale = mLauncher.getDragLayer().getDescendantRectRelativeToSelf(v, folderLocation);
2128            target.removeView(v);
2129
2130            FolderIcon fi =
2131                mLauncher.addFolder(target, container, screen, targetCell[0], targetCell[1]);
2132            destInfo.cellX = -1;
2133            destInfo.cellY = -1;
2134            sourceInfo.cellX = -1;
2135            sourceInfo.cellY = -1;
2136
2137            // If the dragView is null, we can't animate
2138            boolean animate = dragView != null;
2139            if (animate) {
2140                fi.performCreateAnimation(destInfo, v, sourceInfo, dragView, folderLocation, scale,
2141                        postAnimationRunnable);
2142            } else {
2143                fi.addItem(destInfo);
2144                fi.addItem(sourceInfo);
2145            }
2146            return true;
2147        }
2148        return false;
2149    }
2150
2151    boolean addToExistingFolderIfNecessary(View newView, CellLayout target, int[] targetCell,
2152            DragObject d, boolean external) {
2153        View dropOverView = target.getChildAt(targetCell[0], targetCell[1]);
2154        if (dropOverView instanceof FolderIcon) {
2155            FolderIcon fi = (FolderIcon) dropOverView;
2156            if (fi.acceptDrop(d.dragInfo)) {
2157                fi.onDrop(d);
2158
2159                // if the drag started here, we need to remove it from the workspace
2160                if (!external) {
2161                    getParentCellLayoutForView(mDragInfo.cell).removeView(mDragInfo.cell);
2162                }
2163                return true;
2164            }
2165        }
2166        return false;
2167    }
2168
2169    public void onDrop(DragObject d) {
2170        mDragViewVisualCenter = getDragViewVisualCenter(d.x, d.y, d.xOffset, d.yOffset, d.dragView,
2171                mDragViewVisualCenter);
2172
2173        // We want the point to be mapped to the dragTarget.
2174        if (mDragTargetLayout != null) {
2175            if (mLauncher.isHotseatLayout(mDragTargetLayout)) {
2176                mapPointFromSelfToSibling(mLauncher.getHotseat(), mDragViewVisualCenter);
2177            } else {
2178                mapPointFromSelfToChild(mDragTargetLayout, mDragViewVisualCenter, null);
2179            }
2180        }
2181
2182        CellLayout dropTargetLayout = mDragTargetLayout;
2183
2184        int snapScreen = -1;
2185        if (d.dragSource != this) {
2186            final int[] touchXY = new int[] { (int) mDragViewVisualCenter[0],
2187                    (int) mDragViewVisualCenter[1] };
2188            onDropExternal(touchXY, d.dragInfo, dropTargetLayout, false, d);
2189        } else if (mDragInfo != null) {
2190            final View cell = mDragInfo.cell;
2191
2192            if (dropTargetLayout != null) {
2193                // Move internally
2194                boolean hasMovedLayouts = (getParentCellLayoutForView(cell) != dropTargetLayout);
2195                boolean hasMovedIntoHotseat = mLauncher.isHotseatLayout(dropTargetLayout);
2196                long container = hasMovedIntoHotseat ?
2197                        LauncherSettings.Favorites.CONTAINER_HOTSEAT :
2198                        LauncherSettings.Favorites.CONTAINER_DESKTOP;
2199                int screen = (mTargetCell[0] < 0) ?
2200                        mDragInfo.screen : indexOfChild(dropTargetLayout);
2201                int spanX = mDragInfo != null ? mDragInfo.spanX : 1;
2202                int spanY = mDragInfo != null ? mDragInfo.spanY : 1;
2203                // First we find the cell nearest to point at which the item is
2204                // dropped, without any consideration to whether there is an item there.
2205                mTargetCell = findNearestArea((int) mDragViewVisualCenter[0], (int)
2206                        mDragViewVisualCenter[1], spanX, spanY, dropTargetLayout, mTargetCell);
2207                // If the item being dropped is a shortcut and the nearest drop
2208                // cell also contains a shortcut, then create a folder with the two shortcuts.
2209                if (!mInScrollArea && createUserFolderIfNecessary(cell, container,
2210                        dropTargetLayout, mTargetCell, false, d.dragView, null)) {
2211                    return;
2212                }
2213
2214                if (addToExistingFolderIfNecessary(cell, dropTargetLayout, mTargetCell, d, false)) {
2215                    return;
2216                }
2217
2218                // Aside from the special case where we're dropping a shortcut onto a shortcut,
2219                // we need to find the nearest cell location that is vacant
2220                mTargetCell = findNearestVacantArea((int) mDragViewVisualCenter[0],
2221                        (int) mDragViewVisualCenter[1], mDragInfo.spanX, mDragInfo.spanY, cell,
2222                        dropTargetLayout, mTargetCell);
2223
2224                if (mCurrentPage != screen && !hasMovedIntoHotseat) {
2225                    snapScreen = screen;
2226                    snapToPage(screen);
2227                }
2228
2229                if (mTargetCell[0] >= 0 && mTargetCell[1] >= 0) {
2230                    if (hasMovedLayouts) {
2231                        // Reparent the view
2232                        getParentCellLayoutForView(cell).removeView(cell);
2233                        addInScreen(cell, container, screen, mTargetCell[0], mTargetCell[1],
2234                                mDragInfo.spanX, mDragInfo.spanY);
2235                    }
2236
2237                    // update the item's position after drop
2238                    final ItemInfo info = (ItemInfo) cell.getTag();
2239                    CellLayout.LayoutParams lp = (CellLayout.LayoutParams) cell.getLayoutParams();
2240                    dropTargetLayout.onMove(cell, mTargetCell[0], mTargetCell[1]);
2241                    lp.cellX = mTargetCell[0];
2242                    lp.cellY = mTargetCell[1];
2243                    cell.setId(LauncherModel.getCellLayoutChildId(container, mDragInfo.screen,
2244                            mTargetCell[0], mTargetCell[1], mDragInfo.spanX, mDragInfo.spanY));
2245
2246                    if (container != LauncherSettings.Favorites.CONTAINER_HOTSEAT &&
2247                            cell instanceof LauncherAppWidgetHostView) {
2248                        final CellLayout cellLayout = dropTargetLayout;
2249                        // We post this call so that the widget has a chance to be placed
2250                        // in its final location
2251
2252                        final LauncherAppWidgetHostView hostView = (LauncherAppWidgetHostView) cell;
2253                        AppWidgetProviderInfo pinfo = hostView.getAppWidgetInfo();
2254                        if (pinfo.resizeMode != AppWidgetProviderInfo.RESIZE_NONE) {
2255                            final Runnable resizeRunnable = new Runnable() {
2256                                public void run() {
2257                                    DragLayer dragLayer = mLauncher.getDragLayer();
2258                                    dragLayer.addResizeFrame(info, hostView, cellLayout);
2259                                }
2260                            };
2261                            post(new Runnable() {
2262                                public void run() {
2263                                    if (!isPageMoving()) {
2264                                        resizeRunnable.run();
2265                                    } else {
2266                                        mDelayedResizeRunnable = resizeRunnable;
2267                                    }
2268                                }
2269                            });
2270                        }
2271                    }
2272
2273                    LauncherModel.moveItemInDatabase(mLauncher, info, container, screen, lp.cellX,
2274                            lp.cellY);
2275                }
2276            }
2277
2278            final CellLayout parent = (CellLayout) cell.getParent().getParent();
2279
2280            // Prepare it to be animated into its new position
2281            // This must be called after the view has been re-parented
2282            final Runnable disableHardwareLayersRunnable = new Runnable() {
2283                @Override
2284                public void run() {
2285                    mAnimatingViewIntoPlace = false;
2286                    updateChildrenLayersEnabled();
2287                }
2288            };
2289            mAnimatingViewIntoPlace = true;
2290            if (d.dragView.hasDrawn()) {
2291                int duration = snapScreen < 0 ? -1 : ADJACENT_SCREEN_DROP_DURATION;
2292                setFinalScrollForPageChange(snapScreen);
2293                mLauncher.getDragLayer().animateViewIntoPosition(d.dragView, cell, duration,
2294                        disableHardwareLayersRunnable);
2295                resetFinalScrollForPageChange(snapScreen);
2296            } else {
2297                cell.setVisibility(VISIBLE);
2298            }
2299            parent.onDropChild(cell);
2300        }
2301    }
2302
2303    public void setFinalScrollForPageChange(int screen) {
2304        if (screen >= 0) {
2305            mSavedScrollX = getScrollX();
2306            CellLayout cl = (CellLayout) getChildAt(screen);
2307            mSavedTranslationX = cl.getTranslationX();
2308            mSavedRotationY = cl.getRotationY();
2309            final int newX = getChildOffset(screen) - getRelativeChildOffset(screen);
2310            setScrollX(newX);
2311            cl.setTranslationX(0f);
2312            cl.setRotationY(0f);
2313        }
2314    }
2315
2316    public void resetFinalScrollForPageChange(int screen) {
2317        if (screen >= 0) {
2318            CellLayout cl = (CellLayout) getChildAt(screen);
2319            setScrollX(mSavedScrollX);
2320            cl.setTranslationX(mSavedTranslationX);
2321            cl.setRotationY(mSavedRotationY);
2322        }
2323    }
2324
2325    public void getViewLocationRelativeToSelf(View v, int[] location) {
2326        getLocationInWindow(location);
2327        int x = location[0];
2328        int y = location[1];
2329
2330        v.getLocationInWindow(location);
2331        int vX = location[0];
2332        int vY = location[1];
2333
2334        location[0] = vX - x;
2335        location[1] = vY - y;
2336    }
2337
2338    public void onDragEnter(DragObject d) {
2339        if (mDragTargetLayout != null) {
2340            mDragTargetLayout.setIsDragOverlapping(false);
2341            mDragTargetLayout.onDragExit();
2342        }
2343        mDragTargetLayout = getCurrentDropLayout();
2344        mDragTargetLayout.setIsDragOverlapping(true);
2345        mDragTargetLayout.onDragEnter();
2346
2347        // Because we don't have space in the Phone UI (the CellLayouts run to the edge) we
2348        // don't need to show the outlines
2349        if (LauncherApplication.isScreenLarge()) {
2350            showOutlines();
2351        }
2352    }
2353
2354    private void doDragExit(DragObject d) {
2355        // Clean up folders
2356        cleanupFolderCreation(d);
2357
2358        // Reset the scroll area and previous drag target
2359        onResetScrollArea();
2360
2361        if (mDragTargetLayout != null) {
2362            mDragTargetLayout.setIsDragOverlapping(false);
2363            mDragTargetLayout.onDragExit();
2364        }
2365        mLastDragOverView = null;
2366
2367        if (!mIsPageMoving) {
2368            hideOutlines();
2369        }
2370    }
2371
2372    public void onDragExit(DragObject d) {
2373        doDragExit(d);
2374    }
2375
2376    public DropTarget getDropTargetDelegate(DragObject d) {
2377        return null;
2378    }
2379
2380    /**
2381     * Tests to see if the drop will be accepted by Launcher, and if so, includes additional data
2382     * in the returned structure related to the widgets that match the drop (or a null list if it is
2383     * a shortcut drop).  If the drop is not accepted then a null structure is returned.
2384     */
2385    private Pair<Integer, List<WidgetMimeTypeHandlerData>> validateDrag(DragEvent event) {
2386        final LauncherModel model = mLauncher.getModel();
2387        final ClipDescription desc = event.getClipDescription();
2388        final int mimeTypeCount = desc.getMimeTypeCount();
2389        for (int i = 0; i < mimeTypeCount; ++i) {
2390            final String mimeType = desc.getMimeType(i);
2391            if (mimeType.equals(InstallShortcutReceiver.SHORTCUT_MIMETYPE)) {
2392                return new Pair<Integer, List<WidgetMimeTypeHandlerData>>(i, null);
2393            } else {
2394                final List<WidgetMimeTypeHandlerData> widgets =
2395                    model.resolveWidgetsForMimeType(mContext, mimeType);
2396                if (widgets.size() > 0) {
2397                    return new Pair<Integer, List<WidgetMimeTypeHandlerData>>(i, widgets);
2398                }
2399            }
2400        }
2401        return null;
2402    }
2403
2404    /**
2405     * Global drag and drop handler
2406     */
2407    @Override
2408    public boolean onDragEvent(DragEvent event) {
2409        final ClipDescription desc = event.getClipDescription();
2410        final CellLayout layout = (CellLayout) getChildAt(mCurrentPage);
2411        final int[] pos = new int[2];
2412        layout.getLocationOnScreen(pos);
2413        // We need to offset the drag coordinates to layout coordinate space
2414        final int x = (int) event.getX() - pos[0];
2415        final int y = (int) event.getY() - pos[1];
2416
2417        switch (event.getAction()) {
2418        case DragEvent.ACTION_DRAG_STARTED: {
2419            // Validate this drag
2420            Pair<Integer, List<WidgetMimeTypeHandlerData>> test = validateDrag(event);
2421            if (test != null) {
2422                boolean isShortcut = (test.second == null);
2423                if (isShortcut) {
2424                    // Check if we have enough space on this screen to add a new shortcut
2425                    if (!layout.findCellForSpan(pos, 1, 1)) {
2426                        mLauncher.showOutOfSpaceMessage();
2427                        return false;
2428                    }
2429                }
2430            } else {
2431                // Show error message if we couldn't accept any of the items
2432                Toast.makeText(mContext, mContext.getString(R.string.external_drop_widget_error),
2433                        Toast.LENGTH_SHORT).show();
2434                return false;
2435            }
2436
2437            // Create the drag outline
2438            // We need to add extra padding to the bitmap to make room for the glow effect
2439            final Canvas canvas = new Canvas();
2440            final int bitmapPadding = HolographicOutlineHelper.MAX_OUTER_BLUR_RADIUS;
2441            mDragOutline = createExternalDragOutline(canvas, bitmapPadding);
2442
2443            // Show the current page outlines to indicate that we can accept this drop
2444            showOutlines();
2445            layout.onDragEnter();
2446            layout.visualizeDropLocation(null, mDragOutline, x, y, 1, 1, null, null);
2447
2448            return true;
2449        }
2450        case DragEvent.ACTION_DRAG_LOCATION:
2451            // Visualize the drop location
2452            layout.visualizeDropLocation(null, mDragOutline, x, y, 1, 1, null, null);
2453            return true;
2454        case DragEvent.ACTION_DROP: {
2455            // Try and add any shortcuts
2456            final LauncherModel model = mLauncher.getModel();
2457            final ClipData data = event.getClipData();
2458
2459            // We assume that the mime types are ordered in descending importance of
2460            // representation. So we enumerate the list of mime types and alert the
2461            // user if any widgets can handle the drop.  Only the most preferred
2462            // representation will be handled.
2463            pos[0] = x;
2464            pos[1] = y;
2465            Pair<Integer, List<WidgetMimeTypeHandlerData>> test = validateDrag(event);
2466            if (test != null) {
2467                final int index = test.first;
2468                final List<WidgetMimeTypeHandlerData> widgets = test.second;
2469                final boolean isShortcut = (widgets == null);
2470                final String mimeType = desc.getMimeType(index);
2471                if (isShortcut) {
2472                    final Intent intent = data.getItemAt(index).getIntent();
2473                    Object info = model.infoFromShortcutIntent(mContext, intent, data.getIcon());
2474                    onDropExternal(new int[] { x, y }, info, layout, false);
2475                } else {
2476                    if (widgets.size() == 1) {
2477                        // If there is only one item, then go ahead and add and configure
2478                        // that widget
2479                        final AppWidgetProviderInfo widgetInfo = widgets.get(0).widgetInfo;
2480                        final PendingAddWidgetInfo createInfo =
2481                                new PendingAddWidgetInfo(widgetInfo, mimeType, data);
2482                        mLauncher.addAppWidgetFromDrop(createInfo,
2483                            LauncherSettings.Favorites.CONTAINER_DESKTOP, mCurrentPage, null, pos);
2484                    } else {
2485                        // Show the widget picker dialog if there is more than one widget
2486                        // that can handle this data type
2487                        final InstallWidgetReceiver.WidgetListAdapter adapter =
2488                            new InstallWidgetReceiver.WidgetListAdapter(mLauncher, mimeType,
2489                                    data, widgets, layout, mCurrentPage, pos);
2490                        final AlertDialog.Builder builder =
2491                            new AlertDialog.Builder(mContext);
2492                        builder.setAdapter(adapter, adapter);
2493                        builder.setCancelable(true);
2494                        builder.setTitle(mContext.getString(
2495                                R.string.external_drop_widget_pick_title));
2496                        builder.setIcon(R.drawable.ic_no_applications);
2497                        builder.show();
2498                    }
2499                }
2500            }
2501            return true;
2502        }
2503        case DragEvent.ACTION_DRAG_ENDED:
2504            // Hide the page outlines after the drop
2505            layout.onDragExit();
2506            hideOutlines();
2507            return true;
2508        }
2509        return super.onDragEvent(event);
2510    }
2511
2512    /*
2513    *
2514    * Convert the 2D coordinate xy from the parent View's coordinate space to this CellLayout's
2515    * coordinate space. The argument xy is modified with the return result.
2516    *
2517    */
2518   void mapPointFromSelfToChild(View v, float[] xy) {
2519       mapPointFromSelfToChild(v, xy, null);
2520   }
2521
2522   /*
2523    *
2524    * Convert the 2D coordinate xy from the parent View's coordinate space to this CellLayout's
2525    * coordinate space. The argument xy is modified with the return result.
2526    *
2527    * if cachedInverseMatrix is not null, this method will just use that matrix instead of
2528    * computing it itself; we use this to avoid redundant matrix inversions in
2529    * findMatchingPageForDragOver
2530    *
2531    */
2532   void mapPointFromSelfToChild(View v, float[] xy, Matrix cachedInverseMatrix) {
2533       if (cachedInverseMatrix == null) {
2534           v.getMatrix().invert(mTempInverseMatrix);
2535           cachedInverseMatrix = mTempInverseMatrix;
2536       }
2537       xy[0] = xy[0] + mScrollX - v.getLeft();
2538       xy[1] = xy[1] + mScrollY - v.getTop();
2539       cachedInverseMatrix.mapPoints(xy);
2540   }
2541
2542   /*
2543    * Maps a point from the Workspace's coordinate system to another sibling view's. (Workspace
2544    * covers the full screen)
2545    */
2546   void mapPointFromSelfToSibling(View v, float[] xy) {
2547       xy[0] = xy[0] - v.getLeft();
2548       xy[1] = xy[1] - v.getTop();
2549   }
2550
2551   /*
2552    *
2553    * Convert the 2D coordinate xy from this CellLayout's coordinate space to
2554    * the parent View's coordinate space. The argument xy is modified with the return result.
2555    *
2556    */
2557   void mapPointFromChildToSelf(View v, float[] xy) {
2558       v.getMatrix().mapPoints(xy);
2559       xy[0] -= (mScrollX - v.getLeft());
2560       xy[1] -= (mScrollY - v.getTop());
2561   }
2562
2563   static private float squaredDistance(float[] point1, float[] point2) {
2564        float distanceX = point1[0] - point2[0];
2565        float distanceY = point2[1] - point2[1];
2566        return distanceX * distanceX + distanceY * distanceY;
2567   }
2568
2569    /*
2570     *
2571     * Returns true if the passed CellLayout cl overlaps with dragView
2572     *
2573     */
2574    boolean overlaps(CellLayout cl, DragView dragView,
2575            int dragViewX, int dragViewY, Matrix cachedInverseMatrix) {
2576        // Transform the coordinates of the item being dragged to the CellLayout's coordinates
2577        final float[] draggedItemTopLeft = mTempDragCoordinates;
2578        draggedItemTopLeft[0] = dragViewX;
2579        draggedItemTopLeft[1] = dragViewY;
2580        final float[] draggedItemBottomRight = mTempDragBottomRightCoordinates;
2581        draggedItemBottomRight[0] = draggedItemTopLeft[0] + dragView.getDragRegionWidth();
2582        draggedItemBottomRight[1] = draggedItemTopLeft[1] + dragView.getDragRegionHeight();
2583
2584        // Transform the dragged item's top left coordinates
2585        // to the CellLayout's local coordinates
2586        mapPointFromSelfToChild(cl, draggedItemTopLeft, cachedInverseMatrix);
2587        float overlapRegionLeft = Math.max(0f, draggedItemTopLeft[0]);
2588        float overlapRegionTop = Math.max(0f, draggedItemTopLeft[1]);
2589
2590        if (overlapRegionLeft <= cl.getWidth() && overlapRegionTop >= 0) {
2591            // Transform the dragged item's bottom right coordinates
2592            // to the CellLayout's local coordinates
2593            mapPointFromSelfToChild(cl, draggedItemBottomRight, cachedInverseMatrix);
2594            float overlapRegionRight = Math.min(cl.getWidth(), draggedItemBottomRight[0]);
2595            float overlapRegionBottom = Math.min(cl.getHeight(), draggedItemBottomRight[1]);
2596
2597            if (overlapRegionRight >= 0 && overlapRegionBottom <= cl.getHeight()) {
2598                float overlap = (overlapRegionRight - overlapRegionLeft) *
2599                         (overlapRegionBottom - overlapRegionTop);
2600                if (overlap > 0) {
2601                    return true;
2602                }
2603             }
2604        }
2605        return false;
2606    }
2607
2608    /*
2609     *
2610     * This method returns the CellLayout that is currently being dragged to. In order to drag
2611     * to a CellLayout, either the touch point must be directly over the CellLayout, or as a second
2612     * strategy, we see if the dragView is overlapping any CellLayout and choose the closest one
2613     *
2614     * Return null if no CellLayout is currently being dragged over
2615     *
2616     */
2617    private CellLayout findMatchingPageForDragOver(
2618            DragView dragView, float originX, float originY, boolean exact) {
2619        // We loop through all the screens (ie CellLayouts) and see which ones overlap
2620        // with the item being dragged and then choose the one that's closest to the touch point
2621        final int screenCount = getChildCount();
2622        CellLayout bestMatchingScreen = null;
2623        float smallestDistSoFar = Float.MAX_VALUE;
2624
2625        for (int i = 0; i < screenCount; i++) {
2626            CellLayout cl = (CellLayout) getChildAt(i);
2627
2628            final float[] touchXy = {originX, originY};
2629            // Transform the touch coordinates to the CellLayout's local coordinates
2630            // If the touch point is within the bounds of the cell layout, we can return immediately
2631            cl.getMatrix().invert(mTempInverseMatrix);
2632            mapPointFromSelfToChild(cl, touchXy, mTempInverseMatrix);
2633
2634            if (touchXy[0] >= 0 && touchXy[0] <= cl.getWidth() &&
2635                    touchXy[1] >= 0 && touchXy[1] <= cl.getHeight()) {
2636                return cl;
2637            }
2638
2639            if (!exact && overlaps(cl, dragView, (int) originX, (int) originY, mTempInverseMatrix)) {
2640                // Get the center of the cell layout in screen coordinates
2641                final float[] cellLayoutCenter = mTempCellLayoutCenterCoordinates;
2642                cellLayoutCenter[0] = cl.getWidth()/2;
2643                cellLayoutCenter[1] = cl.getHeight()/2;
2644                mapPointFromChildToSelf(cl, cellLayoutCenter);
2645
2646                touchXy[0] = originX;
2647                touchXy[1] = originY;
2648
2649                // Calculate the distance between the center of the CellLayout
2650                // and the touch point
2651                float dist = squaredDistance(touchXy, cellLayoutCenter);
2652
2653                if (dist < smallestDistSoFar) {
2654                    smallestDistSoFar = dist;
2655                    bestMatchingScreen = cl;
2656                }
2657            }
2658        }
2659        return bestMatchingScreen;
2660    }
2661
2662    // This is used to compute the visual center of the dragView. This point is then
2663    // used to visualize drop locations and determine where to drop an item. The idea is that
2664    // the visual center represents the user's interpretation of where the item is, and hence
2665    // is the appropriate point to use when determining drop location.
2666    private float[] getDragViewVisualCenter(int x, int y, int xOffset, int yOffset,
2667            DragView dragView, float[] recycle) {
2668        float res[];
2669        if (recycle == null) {
2670            res = new float[2];
2671        } else {
2672            res = recycle;
2673        }
2674
2675        // First off, the drag view has been shifted in a way that is not represented in the
2676        // x and y values or the x/yOffsets. Here we account for that shift.
2677        x += getResources().getDimensionPixelSize(R.dimen.dragViewOffsetX);
2678        y += getResources().getDimensionPixelSize(R.dimen.dragViewOffsetY);
2679
2680        // These represent the visual top and left of drag view if a dragRect was provided.
2681        // If a dragRect was not provided, then they correspond to the actual view left and
2682        // top, as the dragRect is in that case taken to be the entire dragView.
2683        // R.dimen.dragViewOffsetY.
2684        int left = x - xOffset;
2685        int top = y - yOffset;
2686
2687        // In order to find the visual center, we shift by half the dragRect
2688        res[0] = left + dragView.getDragRegion().width() / 2;
2689        res[1] = top + dragView.getDragRegion().height() / 2;
2690
2691        return res;
2692    }
2693
2694    private boolean isDragWidget(DragObject d) {
2695        return (d.dragInfo instanceof LauncherAppWidgetInfo ||
2696                d.dragInfo instanceof PendingAddWidgetInfo);
2697    }
2698    private boolean isExternalDragWidget(DragObject d) {
2699        return d.dragSource != this && isDragWidget(d);
2700    }
2701
2702    public void onDragOver(DragObject d) {
2703        // Skip drag over events while we are dragging over side pages
2704        if (mInScrollArea) return;
2705        if (mIsSwitchingState) return;
2706
2707        Rect r = new Rect();
2708        CellLayout layout = null;
2709        ItemInfo item = (ItemInfo) d.dragInfo;
2710
2711        // Ensure that we have proper spans for the item that we are dropping
2712        if (item.spanX < 0 || item.spanY < 0) throw new RuntimeException("Improper spans found");
2713        mDragViewVisualCenter = getDragViewVisualCenter(d.x, d.y, d.xOffset, d.yOffset,
2714            d.dragView, mDragViewVisualCenter);
2715
2716        // Identify whether we have dragged over a side page
2717        if (isSmall()) {
2718            if (mLauncher.getHotseat() != null && !isExternalDragWidget(d)) {
2719                mLauncher.getHotseat().getHitRect(r);
2720                if (r.contains(d.x, d.y)) {
2721                    layout = mLauncher.getHotseat().getLayout();
2722                }
2723            }
2724            if (layout == null) {
2725                layout = findMatchingPageForDragOver(d.dragView, d.x, d.y, true);
2726            }
2727            if (layout != mDragTargetLayout) {
2728                // Cancel all intermediate folder states
2729                cleanupFolderCreation(d);
2730
2731                if (mDragTargetLayout != null) {
2732                    mDragTargetLayout.setIsDragOverlapping(false);
2733                    mDragTargetLayout.onDragExit();
2734                }
2735                mDragTargetLayout = layout;
2736                if (mDragTargetLayout != null) {
2737                    mDragTargetLayout.setIsDragOverlapping(true);
2738                    mDragTargetLayout.onDragEnter();
2739                } else {
2740                    mLastDragOverView = null;
2741                }
2742
2743                boolean isInSpringLoadedMode = (mState == State.SPRING_LOADED);
2744                if (isInSpringLoadedMode) {
2745                    if (mLauncher.isHotseatLayout(layout)) {
2746                        mSpringLoadedDragController.cancel();
2747                    } else {
2748                        mSpringLoadedDragController.setAlarm(mDragTargetLayout);
2749                    }
2750                }
2751            }
2752        } else {
2753            // Test to see if we are over the hotseat otherwise just use the current page
2754            if (mLauncher.getHotseat() != null && !isDragWidget(d)) {
2755                mLauncher.getHotseat().getHitRect(r);
2756                if (r.contains(d.x, d.y)) {
2757                    layout = mLauncher.getHotseat().getLayout();
2758                }
2759            }
2760            if (layout == null) {
2761                layout = getCurrentDropLayout();
2762            }
2763            if (layout != mDragTargetLayout) {
2764                if (mDragTargetLayout != null) {
2765                    mDragTargetLayout.setIsDragOverlapping(false);
2766                    mDragTargetLayout.onDragExit();
2767                }
2768                mDragTargetLayout = layout;
2769                mDragTargetLayout.setIsDragOverlapping(true);
2770                mDragTargetLayout.onDragEnter();
2771            }
2772        }
2773
2774        // Handle the drag over
2775        if (mDragTargetLayout != null) {
2776            final View child = (mDragInfo == null) ? null : mDragInfo.cell;
2777
2778            // We want the point to be mapped to the dragTarget.
2779            if (mLauncher.isHotseatLayout(mDragTargetLayout)) {
2780                mapPointFromSelfToSibling(mLauncher.getHotseat(), mDragViewVisualCenter);
2781            } else {
2782                mapPointFromSelfToChild(mDragTargetLayout, mDragViewVisualCenter, null);
2783            }
2784            ItemInfo info = (ItemInfo) d.dragInfo;
2785
2786            mTargetCell = findNearestArea((int) mDragViewVisualCenter[0],
2787                    (int) mDragViewVisualCenter[1], 1, 1, mDragTargetLayout, mTargetCell);
2788            final View dragOverView = mDragTargetLayout.getChildAt(mTargetCell[0],
2789                    mTargetCell[1]);
2790
2791            boolean userFolderPending = willCreateUserFolder(info, mDragTargetLayout,
2792                    mTargetCell, false);
2793            boolean isOverFolder = dragOverView instanceof FolderIcon;
2794            if (dragOverView != mLastDragOverView) {
2795                cancelFolderCreation();
2796                if (mLastDragOverView != null && mLastDragOverView instanceof FolderIcon) {
2797                    ((FolderIcon) mLastDragOverView).onDragExit(d.dragInfo);
2798                }
2799            }
2800
2801            if (userFolderPending && dragOverView != mLastDragOverView) {
2802                mFolderCreationAlarm.setOnAlarmListener(new
2803                        FolderCreationAlarmListener(mDragTargetLayout, mTargetCell[0], mTargetCell[1]));
2804                mFolderCreationAlarm.setAlarm(FOLDER_CREATION_TIMEOUT);
2805            }
2806
2807            if (dragOverView != mLastDragOverView && isOverFolder) {
2808                ((FolderIcon) dragOverView).onDragEnter(d.dragInfo);
2809                if (mDragTargetLayout != null) {
2810                    mDragTargetLayout.clearDragOutlines();
2811                }
2812            }
2813            mLastDragOverView = dragOverView;
2814
2815            if (!mCreateUserFolderOnDrop && !isOverFolder) {
2816                mDragTargetLayout.visualizeDropLocation(child, mDragOutline,
2817                        (int) mDragViewVisualCenter[0], (int) mDragViewVisualCenter[1],
2818                        item.spanX, item.spanY, d.dragView.getDragVisualizeOffset(),
2819                        d.dragView.getDragRegion());
2820            }
2821        }
2822    }
2823
2824    private void cleanupFolderCreation(DragObject d) {
2825        if (mDragFolderRingAnimator != null && mCreateUserFolderOnDrop) {
2826            mDragFolderRingAnimator.animateToNaturalState();
2827        }
2828        if (mLastDragOverView != null && mLastDragOverView instanceof FolderIcon) {
2829            if (d != null) {
2830                ((FolderIcon) mLastDragOverView).onDragExit(d.dragInfo);
2831            }
2832        }
2833        mFolderCreationAlarm.cancelAlarm();
2834    }
2835
2836    private void cancelFolderCreation() {
2837        if (mDragFolderRingAnimator != null && mCreateUserFolderOnDrop) {
2838            mDragFolderRingAnimator.animateToNaturalState();
2839        }
2840        mCreateUserFolderOnDrop = false;
2841        mFolderCreationAlarm.cancelAlarm();
2842    }
2843
2844    class FolderCreationAlarmListener implements OnAlarmListener {
2845        CellLayout layout;
2846        int cellX;
2847        int cellY;
2848
2849        public FolderCreationAlarmListener(CellLayout layout, int cellX, int cellY) {
2850            this.layout = layout;
2851            this.cellX = cellX;
2852            this.cellY = cellY;
2853        }
2854
2855        public void onAlarm(Alarm alarm) {
2856            if (mDragFolderRingAnimator == null) {
2857                mDragFolderRingAnimator = new FolderRingAnimator(mLauncher, null);
2858            }
2859            mDragFolderRingAnimator.setCell(cellX, cellY);
2860            mDragFolderRingAnimator.setCellLayout(layout);
2861            mDragFolderRingAnimator.animateToAcceptState();
2862            layout.showFolderAccept(mDragFolderRingAnimator);
2863            layout.clearDragOutlines();
2864            mCreateUserFolderOnDrop = true;
2865        }
2866    }
2867
2868    @Override
2869    public void getHitRect(Rect outRect) {
2870        // We want the workspace to have the whole area of the display (it will find the correct
2871        // cell layout to drop to in the existing drag/drop logic.
2872        outRect.set(0, 0, mDisplayWidth, mDisplayHeight);
2873    }
2874
2875    /**
2876     * Add the item specified by dragInfo to the given layout.
2877     * @return true if successful
2878     */
2879    public boolean addExternalItemToScreen(ItemInfo dragInfo, CellLayout layout) {
2880        if (layout.findCellForSpan(mTempEstimate, dragInfo.spanX, dragInfo.spanY)) {
2881            onDropExternal(dragInfo.dropPos, (ItemInfo) dragInfo, (CellLayout) layout, false);
2882            return true;
2883        }
2884        mLauncher.showOutOfSpaceMessage();
2885        return false;
2886    }
2887
2888    private void onDropExternal(int[] touchXY, Object dragInfo,
2889            CellLayout cellLayout, boolean insertAtFirst) {
2890        onDropExternal(touchXY, dragInfo, cellLayout, insertAtFirst, null);
2891    }
2892
2893    /**
2894     * Drop an item that didn't originate on one of the workspace screens.
2895     * It may have come from Launcher (e.g. from all apps or customize), or it may have
2896     * come from another app altogether.
2897     *
2898     * NOTE: This can also be called when we are outside of a drag event, when we want
2899     * to add an item to one of the workspace screens.
2900     */
2901    private void onDropExternal(final int[] touchXY, final Object dragInfo,
2902            final CellLayout cellLayout, boolean insertAtFirst, DragObject d) {
2903        final Runnable exitSpringLoadedRunnable = new Runnable() {
2904            @Override
2905            public void run() {
2906                mLauncher.exitSpringLoadedDragModeDelayed(true, false);
2907            }
2908        };
2909
2910        ItemInfo info = (ItemInfo) dragInfo;
2911        int spanX = info.spanX;
2912        int spanY = info.spanY;
2913        if (mDragInfo != null) {
2914            spanX = mDragInfo.spanX;
2915            spanY = mDragInfo.spanY;
2916        }
2917
2918        final long container = mLauncher.isHotseatLayout(cellLayout) ?
2919                LauncherSettings.Favorites.CONTAINER_HOTSEAT :
2920                    LauncherSettings.Favorites.CONTAINER_DESKTOP;
2921        final int screen = indexOfChild(cellLayout);
2922        if (!mLauncher.isHotseatLayout(cellLayout) && screen != mCurrentPage
2923                && mState != State.SPRING_LOADED) {
2924            snapToPage(screen);
2925        }
2926
2927        if (info instanceof PendingAddItemInfo) {
2928            final PendingAddItemInfo pendingInfo = (PendingAddItemInfo) dragInfo;
2929
2930            boolean findNearestVacantCell = true;
2931            if (pendingInfo.itemType == LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT) {
2932                mTargetCell = findNearestArea((int) touchXY[0], (int) touchXY[1], spanX, spanY,
2933                        cellLayout, mTargetCell);
2934                if (willCreateUserFolder((ItemInfo) d.dragInfo, mDragTargetLayout, mTargetCell,
2935                        true) || willAddToExistingUserFolder((ItemInfo) d.dragInfo,
2936                                mDragTargetLayout, mTargetCell)) {
2937                    findNearestVacantCell = false;
2938                }
2939            }
2940            if (findNearestVacantCell) {
2941                    mTargetCell = findNearestVacantArea(touchXY[0], touchXY[1], spanX, spanY, null,
2942                        cellLayout, mTargetCell);
2943            }
2944
2945            Runnable onAnimationCompleteRunnable = new Runnable() {
2946                @Override
2947                public void run() {
2948                    // When dragging and dropping from customization tray, we deal with creating
2949                    // widgets/shortcuts/folders in a slightly different way
2950                    switch (pendingInfo.itemType) {
2951                    case LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET:
2952                        mLauncher.addAppWidgetFromDrop((PendingAddWidgetInfo) pendingInfo,
2953                                container, screen, mTargetCell, null);
2954                        break;
2955                    case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT:
2956                        mLauncher.processShortcutFromDrop(pendingInfo.componentName,
2957                                container, screen, mTargetCell, null);
2958                        break;
2959                    default:
2960                        throw new IllegalStateException("Unknown item type: " +
2961                                pendingInfo.itemType);
2962                    }
2963                    cellLayout.onDragExit();
2964                }
2965            };
2966
2967            // Now we animate the dragView, (ie. the widget or shortcut preview) into its final
2968            // location and size on the home screen.
2969            RectF r = estimateItemPosition(cellLayout, pendingInfo,
2970                    mTargetCell[0], mTargetCell[1], spanX, spanY);
2971            int loc[] = new int[2];
2972            loc[0] = (int) r.left;
2973            loc[1] = (int) r.top;
2974            setFinalTransitionTransform(cellLayout);
2975            float cellLayoutScale =
2976                    mLauncher.getDragLayer().getDescendantCoordRelativeToSelf(cellLayout, loc);
2977            resetTransitionTransform(cellLayout);
2978
2979            float dragViewScale =  r.width() / d.dragView.getMeasuredWidth();
2980            // The animation will scale the dragView about its center, so we need to center about
2981            // the final location.
2982            loc[0] -= (d.dragView.getMeasuredWidth() - cellLayoutScale * r.width()) / 2;
2983            loc[1] -= (d.dragView.getMeasuredHeight() - cellLayoutScale * r.height()) / 2;
2984
2985            mLauncher.getDragLayer().animateViewIntoPosition(d.dragView, loc,
2986                    dragViewScale * cellLayoutScale, onAnimationCompleteRunnable);
2987        } else {
2988            // This is for other drag/drop cases, like dragging from All Apps
2989            View view = null;
2990
2991            switch (info.itemType) {
2992            case LauncherSettings.Favorites.ITEM_TYPE_APPLICATION:
2993            case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT:
2994                if (info.container == NO_ID && info instanceof ApplicationInfo) {
2995                    // Came from all apps -- make a copy
2996                    info = new ShortcutInfo((ApplicationInfo) info);
2997                }
2998                view = mLauncher.createShortcut(R.layout.application, cellLayout,
2999                        (ShortcutInfo) info);
3000                break;
3001            case LauncherSettings.Favorites.ITEM_TYPE_FOLDER:
3002                view = FolderIcon.fromXml(R.layout.folder_icon, mLauncher, cellLayout,
3003                        (FolderInfo) info, mIconCache);
3004                break;
3005            default:
3006                throw new IllegalStateException("Unknown item type: " + info.itemType);
3007            }
3008
3009            // First we find the cell nearest to point at which the item is
3010            // dropped, without any consideration to whether there is an item there.
3011            if (touchXY != null) {
3012                mTargetCell = findNearestArea((int) touchXY[0], (int) touchXY[1], spanX, spanY,
3013                        cellLayout, mTargetCell);
3014                d.postAnimationRunnable = exitSpringLoadedRunnable;
3015                if (createUserFolderIfNecessary(view, container, cellLayout, mTargetCell, true,
3016                        d.dragView, d.postAnimationRunnable)) {
3017                    return;
3018                }
3019                if (addToExistingFolderIfNecessary(view, cellLayout, mTargetCell, d, true)) {
3020                    return;
3021                }
3022            }
3023
3024            if (touchXY != null) {
3025                // when dragging and dropping, just find the closest free spot
3026                mTargetCell = findNearestVacantArea(touchXY[0], touchXY[1], 1, 1, null,
3027                        cellLayout, mTargetCell);
3028            } else {
3029                cellLayout.findCellForSpan(mTargetCell, 1, 1);
3030            }
3031            addInScreen(view, container, screen, mTargetCell[0], mTargetCell[1], info.spanX,
3032                    info.spanY, insertAtFirst);
3033            cellLayout.onDropChild(view);
3034            CellLayout.LayoutParams lp = (CellLayout.LayoutParams) view.getLayoutParams();
3035            cellLayout.getChildrenLayout().measureChild(view);
3036
3037            LauncherModel.addOrMoveItemInDatabase(mLauncher, info, container, screen,
3038                    lp.cellX, lp.cellY);
3039
3040            if (d.dragView != null) {
3041                // We wrap the animation call in the temporary set and reset of the current
3042                // cellLayout to its final transform -- this means we animate the drag view to
3043                // the correct final location.
3044                setFinalTransitionTransform(cellLayout);
3045                mLauncher.getDragLayer().animateViewIntoPosition(d.dragView, view,
3046                        exitSpringLoadedRunnable);
3047                resetTransitionTransform(cellLayout);
3048            }
3049        }
3050    }
3051
3052    public void setFinalTransitionTransform(CellLayout layout) {
3053        if (isSwitchingState()) {
3054            int index = indexOfChild(layout);
3055            mCurrentScaleX = layout.getScaleX();
3056            mCurrentScaleY = layout.getScaleY();
3057            mCurrentTranslationX = layout.getTranslationX();
3058            mCurrentTranslationY = layout.getTranslationY();
3059            mCurrentRotationY = layout.getRotationY();
3060            layout.setScaleX(mNewScaleXs[index]);
3061            layout.setScaleY(mNewScaleYs[index]);
3062            layout.setTranslationX(mNewTranslationXs[index]);
3063            layout.setTranslationY(mNewTranslationYs[index]);
3064            layout.setRotationY(mNewRotationYs[index]);
3065        }
3066    }
3067    public void resetTransitionTransform(CellLayout layout) {
3068        if (isSwitchingState()) {
3069            mCurrentScaleX = layout.getScaleX();
3070            mCurrentScaleY = layout.getScaleY();
3071            mCurrentTranslationX = layout.getTranslationX();
3072            mCurrentTranslationY = layout.getTranslationY();
3073            mCurrentRotationY = layout.getRotationY();
3074            layout.setScaleX(mCurrentScaleX);
3075            layout.setScaleY(mCurrentScaleY);
3076            layout.setTranslationX(mCurrentTranslationX);
3077            layout.setTranslationY(mCurrentTranslationY);
3078            layout.setRotationY(mCurrentRotationY);
3079        }
3080    }
3081
3082    /**
3083     * Return the current {@link CellLayout}, correctly picking the destination
3084     * screen while a scroll is in progress.
3085     */
3086    public CellLayout getCurrentDropLayout() {
3087        return (CellLayout) getChildAt(mNextPage == INVALID_PAGE ? mCurrentPage : mNextPage);
3088    }
3089
3090    /**
3091     * Return the current CellInfo describing our current drag; this method exists
3092     * so that Launcher can sync this object with the correct info when the activity is created/
3093     * destroyed
3094     *
3095     */
3096    public CellLayout.CellInfo getDragInfo() {
3097        return mDragInfo;
3098    }
3099
3100    /**
3101     * Calculate the nearest cell where the given object would be dropped.
3102     *
3103     * pixelX and pixelY should be in the coordinate system of layout
3104     */
3105    private int[] findNearestVacantArea(int pixelX, int pixelY,
3106            int spanX, int spanY, View ignoreView, CellLayout layout, int[] recycle) {
3107        return layout.findNearestVacantArea(
3108                pixelX, pixelY, spanX, spanY, ignoreView, recycle);
3109    }
3110
3111    /**
3112     * Calculate the nearest cell where the given object would be dropped.
3113     *
3114     * pixelX and pixelY should be in the coordinate system of layout
3115     */
3116    private int[] findNearestArea(int pixelX, int pixelY,
3117            int spanX, int spanY, CellLayout layout, int[] recycle) {
3118        return layout.findNearestArea(
3119                pixelX, pixelY, spanX, spanY, recycle);
3120    }
3121
3122    void setup(DragController dragController) {
3123        mSpringLoadedDragController = new SpringLoadedDragController(mLauncher);
3124        mDragController = dragController;
3125
3126        // hardware layers on children are enabled on startup, but should be disabled until
3127        // needed
3128        updateChildrenLayersEnabled();
3129        setWallpaperDimension();
3130    }
3131
3132    /**
3133     * Called at the end of a drag which originated on the workspace.
3134     */
3135    public void onDropCompleted(View target, DragObject d, boolean success) {
3136        if (success) {
3137            if (target != this) {
3138                if (mDragInfo != null) {
3139                    getParentCellLayoutForView(mDragInfo.cell).removeView(mDragInfo.cell);
3140                    if (mDragInfo.cell instanceof DropTarget) {
3141                        mDragController.removeDropTarget((DropTarget) mDragInfo.cell);
3142                    }
3143                }
3144            }
3145        } else if (mDragInfo != null) {
3146            // NOTE: When 'success' is true, onDragExit is called by the DragController before
3147            // calling onDropCompleted(). We call it ourselves here, but maybe this should be
3148            // moved into DragController.cancelDrag().
3149            doDragExit(null);
3150            CellLayout cellLayout;
3151            if (mLauncher.isHotseatLayout(target)) {
3152                cellLayout = mLauncher.getHotseat().getLayout();
3153            } else {
3154                cellLayout = (CellLayout) getChildAt(mDragInfo.screen);
3155            }
3156            cellLayout.onDropChild(mDragInfo.cell);
3157        }
3158        if (d.cancelled &&  mDragInfo.cell != null) {
3159                mDragInfo.cell.setVisibility(VISIBLE);
3160        }
3161        mDragOutline = null;
3162        mDragInfo = null;
3163    }
3164
3165    public boolean isDropEnabled() {
3166        return true;
3167    }
3168
3169    @Override
3170    protected void onRestoreInstanceState(Parcelable state) {
3171        super.onRestoreInstanceState(state);
3172        Launcher.setScreen(mCurrentPage);
3173    }
3174
3175    @Override
3176    public void scrollLeft() {
3177        if (!isSmall() && !mIsSwitchingState) {
3178            super.scrollLeft();
3179        }
3180        Folder openFolder = getOpenFolder();
3181        if (openFolder != null) {
3182            openFolder.completeDragExit();
3183        }
3184    }
3185
3186    @Override
3187    public void scrollRight() {
3188        if (!isSmall() && !mIsSwitchingState) {
3189            super.scrollRight();
3190        }
3191        Folder openFolder = getOpenFolder();
3192        if (openFolder != null) {
3193            openFolder.completeDragExit();
3194        }
3195    }
3196
3197    @Override
3198    public boolean onEnterScrollArea(int x, int y, int direction) {
3199        // Ignore the scroll area if we are dragging over the hot seat
3200        if (mLauncher.getHotseat() != null) {
3201            Rect r = new Rect();
3202            mLauncher.getHotseat().getHitRect(r);
3203            if (r.contains(x, y)) {
3204                return false;
3205            }
3206        }
3207
3208        boolean result = false;
3209        if (!isSmall() && !mIsSwitchingState) {
3210            mInScrollArea = true;
3211
3212            final int page = mCurrentPage + (direction == DragController.SCROLL_LEFT ? -1 : 1);
3213            final CellLayout layout = (CellLayout) getChildAt(page);
3214            cancelFolderCreation();
3215
3216            if (layout != null) {
3217                // Exit the current layout and mark the overlapping layout
3218                if (mDragTargetLayout != null) {
3219                    mDragTargetLayout.setIsDragOverlapping(false);
3220                    mDragTargetLayout.onDragExit();
3221                }
3222                mDragTargetLayout = layout;
3223                mDragTargetLayout.setIsDragOverlapping(true);
3224
3225                // Workspace is responsible for drawing the edge glow on adjacent pages,
3226                // so we need to redraw the workspace when this may have changed.
3227                invalidate();
3228                result = true;
3229            }
3230        }
3231        return result;
3232    }
3233
3234    @Override
3235    public boolean onExitScrollArea() {
3236        boolean result = false;
3237        if (mInScrollArea) {
3238            if (mDragTargetLayout != null) {
3239                // Unmark the overlapping layout and re-enter the current layout
3240                mDragTargetLayout.setIsDragOverlapping(false);
3241                mDragTargetLayout = getCurrentDropLayout();
3242                mDragTargetLayout.onDragEnter();
3243
3244                // Workspace is responsible for drawing the edge glow on adjacent pages,
3245                // so we need to redraw the workspace when this may have changed.
3246                invalidate();
3247                result = true;
3248            }
3249            mInScrollArea = false;
3250        }
3251        return result;
3252    }
3253
3254    private void onResetScrollArea() {
3255        if (mDragTargetLayout != null) {
3256            // Unmark the overlapping layout
3257            mDragTargetLayout.setIsDragOverlapping(false);
3258
3259            // Workspace is responsible for drawing the edge glow on adjacent pages,
3260            // so we need to redraw the workspace when this may have changed.
3261            invalidate();
3262        }
3263        mInScrollArea = false;
3264    }
3265
3266    /**
3267     * Returns a specific CellLayout
3268     */
3269    CellLayout getParentCellLayoutForView(View v) {
3270        ArrayList<CellLayout> layouts = getWorkspaceAndHotseatCellLayouts();
3271        for (CellLayout layout : layouts) {
3272            if (layout.getChildrenLayout().indexOfChild(v) > -1) {
3273                return layout;
3274            }
3275        }
3276        return null;
3277    }
3278
3279    /**
3280     * Returns a list of all the CellLayouts in the workspace.
3281     */
3282    ArrayList<CellLayout> getWorkspaceAndHotseatCellLayouts() {
3283        ArrayList<CellLayout> layouts = new ArrayList<CellLayout>();
3284        int screenCount = getChildCount();
3285        for (int screen = 0; screen < screenCount; screen++) {
3286            layouts.add(((CellLayout) getChildAt(screen)));
3287        }
3288        if (mLauncher.getHotseat() != null) {
3289            layouts.add(mLauncher.getHotseat().getLayout());
3290        }
3291        return layouts;
3292    }
3293
3294    /**
3295     * We should only use this to search for specific children.  Do not use this method to modify
3296     * CellLayoutChildren directly.
3297     */
3298    ArrayList<CellLayoutChildren> getWorkspaceAndHotseatCellLayoutChildren() {
3299        ArrayList<CellLayoutChildren> childrenLayouts = new ArrayList<CellLayoutChildren>();
3300        int screenCount = getChildCount();
3301        for (int screen = 0; screen < screenCount; screen++) {
3302            childrenLayouts.add(((CellLayout) getChildAt(screen)).getChildrenLayout());
3303        }
3304        if (mLauncher.getHotseat() != null) {
3305            childrenLayouts.add(mLauncher.getHotseat().getLayout().getChildrenLayout());
3306        }
3307        return childrenLayouts;
3308    }
3309
3310    public Folder getFolderForTag(Object tag) {
3311        ArrayList<CellLayoutChildren> childrenLayouts = getWorkspaceAndHotseatCellLayoutChildren();
3312        for (CellLayoutChildren layout: childrenLayouts) {
3313            int count = layout.getChildCount();
3314            for (int i = 0; i < count; i++) {
3315                View child = layout.getChildAt(i);
3316                if (child instanceof Folder) {
3317                    Folder f = (Folder) child;
3318                    if (f.getInfo() == tag && f.getInfo().opened) {
3319                        return f;
3320                    }
3321                }
3322            }
3323        }
3324        return null;
3325    }
3326
3327    public View getViewForTag(Object tag) {
3328        ArrayList<CellLayoutChildren> childrenLayouts = getWorkspaceAndHotseatCellLayoutChildren();
3329        for (CellLayoutChildren layout: childrenLayouts) {
3330            int count = layout.getChildCount();
3331            for (int i = 0; i < count; i++) {
3332                View child = layout.getChildAt(i);
3333                if (child.getTag() == tag) {
3334                    return child;
3335                }
3336            }
3337        }
3338        return null;
3339    }
3340
3341    void clearDropTargets() {
3342        ArrayList<CellLayoutChildren> childrenLayouts = getWorkspaceAndHotseatCellLayoutChildren();
3343        for (CellLayoutChildren layout: childrenLayouts) {
3344            int childCount = layout.getChildCount();
3345            for (int j = 0; j < childCount; j++) {
3346                View v = layout.getChildAt(j);
3347                if (v instanceof DropTarget) {
3348                    mDragController.removeDropTarget((DropTarget) v);
3349                }
3350            }
3351        }
3352    }
3353
3354    void removeItems(final ArrayList<ApplicationInfo> apps) {
3355        final AppWidgetManager widgets = AppWidgetManager.getInstance(getContext());
3356
3357        final HashSet<String> packageNames = new HashSet<String>();
3358        final int appCount = apps.size();
3359        for (int i = 0; i < appCount; i++) {
3360            packageNames.add(apps.get(i).componentName.getPackageName());
3361        }
3362
3363        ArrayList<CellLayout> cellLayouts = getWorkspaceAndHotseatCellLayouts();
3364        for (final CellLayout layoutParent: cellLayouts) {
3365            final ViewGroup layout = layoutParent.getChildrenLayout();
3366
3367            // Avoid ANRs by treating each screen separately
3368            post(new Runnable() {
3369                public void run() {
3370                    final ArrayList<View> childrenToRemove = new ArrayList<View>();
3371                    childrenToRemove.clear();
3372
3373                    int childCount = layout.getChildCount();
3374                    for (int j = 0; j < childCount; j++) {
3375                        final View view = layout.getChildAt(j);
3376                        Object tag = view.getTag();
3377
3378                        if (tag instanceof ShortcutInfo) {
3379                            final ShortcutInfo info = (ShortcutInfo) tag;
3380                            final Intent intent = info.intent;
3381                            final ComponentName name = intent.getComponent();
3382
3383                            if (Intent.ACTION_MAIN.equals(intent.getAction()) && name != null) {
3384                                for (String packageName: packageNames) {
3385                                    if (packageName.equals(name.getPackageName())) {
3386                                        LauncherModel.deleteItemFromDatabase(mLauncher, info);
3387                                        childrenToRemove.add(view);
3388                                    }
3389                                }
3390                            }
3391                        } else if (tag instanceof FolderInfo) {
3392                            final FolderInfo info = (FolderInfo) tag;
3393                            final ArrayList<ShortcutInfo> contents = info.contents;
3394                            final int contentsCount = contents.size();
3395                            final ArrayList<ShortcutInfo> appsToRemoveFromFolder =
3396                                    new ArrayList<ShortcutInfo>();
3397
3398                            for (int k = 0; k < contentsCount; k++) {
3399                                final ShortcutInfo appInfo = contents.get(k);
3400                                final Intent intent = appInfo.intent;
3401                                final ComponentName name = intent.getComponent();
3402
3403                                if (Intent.ACTION_MAIN.equals(intent.getAction()) && name != null) {
3404                                    for (String packageName: packageNames) {
3405                                        if (packageName.equals(name.getPackageName())) {
3406                                            appsToRemoveFromFolder.add(appInfo);
3407                                        }
3408                                    }
3409                                }
3410                            }
3411                            for (ShortcutInfo item: appsToRemoveFromFolder) {
3412                                info.remove(item);
3413                                LauncherModel.deleteItemFromDatabase(mLauncher, item);
3414                            }
3415                        } else if (tag instanceof LauncherAppWidgetInfo) {
3416                            final LauncherAppWidgetInfo info = (LauncherAppWidgetInfo) tag;
3417                            final AppWidgetProviderInfo provider =
3418                                    widgets.getAppWidgetInfo(info.appWidgetId);
3419                            if (provider != null) {
3420                                for (String packageName: packageNames) {
3421                                    if (packageName.equals(provider.provider.getPackageName())) {
3422                                        LauncherModel.deleteItemFromDatabase(mLauncher, info);
3423                                        childrenToRemove.add(view);
3424                                    }
3425                                }
3426                            }
3427                        }
3428                    }
3429
3430                    childCount = childrenToRemove.size();
3431                    for (int j = 0; j < childCount; j++) {
3432                        View child = childrenToRemove.get(j);
3433                        // Note: We can not remove the view directly from CellLayoutChildren as this
3434                        // does not re-mark the spaces as unoccupied.
3435                        layoutParent.removeViewInLayout(child);
3436                        if (child instanceof DropTarget) {
3437                            mDragController.removeDropTarget((DropTarget)child);
3438                        }
3439                    }
3440
3441                    if (childCount > 0) {
3442                        layout.requestLayout();
3443                        layout.invalidate();
3444                    }
3445                }
3446            });
3447        }
3448    }
3449
3450    void updateShortcuts(ArrayList<ApplicationInfo> apps) {
3451        ArrayList<CellLayoutChildren> childrenLayouts = getWorkspaceAndHotseatCellLayoutChildren();
3452        for (CellLayoutChildren layout: childrenLayouts) {
3453            int childCount = layout.getChildCount();
3454            for (int j = 0; j < childCount; j++) {
3455                final View view = layout.getChildAt(j);
3456                Object tag = view.getTag();
3457                if (tag instanceof ShortcutInfo) {
3458                    ShortcutInfo info = (ShortcutInfo)tag;
3459                    // We need to check for ACTION_MAIN otherwise getComponent() might
3460                    // return null for some shortcuts (for instance, for shortcuts to
3461                    // web pages.)
3462                    final Intent intent = info.intent;
3463                    final ComponentName name = intent.getComponent();
3464                    if (info.itemType == LauncherSettings.Favorites.ITEM_TYPE_APPLICATION &&
3465                            Intent.ACTION_MAIN.equals(intent.getAction()) && name != null) {
3466                        final int appCount = apps.size();
3467                        for (int k = 0; k < appCount; k++) {
3468                            ApplicationInfo app = apps.get(k);
3469                            if (app.componentName.equals(name)) {
3470                                info.setIcon(mIconCache.getIcon(info.intent));
3471                                ((TextView)view).setCompoundDrawablesWithIntrinsicBounds(null,
3472                                        new FastBitmapDrawable(info.getIcon(mIconCache)),
3473                                        null, null);
3474                                }
3475                        }
3476                    }
3477                }
3478            }
3479        }
3480    }
3481
3482    void moveToDefaultScreen(boolean animate) {
3483        if (!isSmall()) {
3484            if (animate) {
3485                snapToPage(mDefaultPage);
3486            } else {
3487                setCurrentPage(mDefaultPage);
3488            }
3489        }
3490        getChildAt(mDefaultPage).requestFocus();
3491    }
3492
3493    @Override
3494    public void syncPages() {
3495    }
3496
3497    @Override
3498    public void syncPageItems(int page, boolean immediate) {
3499    }
3500
3501    @Override
3502    protected String getCurrentPageDescription() {
3503        int page = (mNextPage != INVALID_PAGE) ? mNextPage : mCurrentPage;
3504        return String.format(mContext.getString(R.string.workspace_scroll_format),
3505                page + 1, getChildCount());
3506    }
3507
3508    public void getLocationInDragLayer(int[] loc) {
3509        mLauncher.getDragLayer().getLocationInDragLayer(this, loc);
3510    }
3511
3512    void setFadeForOverScroll(float fade) {
3513        if (!isScrollingIndicatorEnabled()) return;
3514
3515        mOverscrollFade = fade;
3516        float reducedFade = 0.5f + 0.5f * (1 - fade);
3517        final ViewGroup parent = (ViewGroup) getParent();
3518        final ImageView dockDivider = (ImageView) (parent.findViewById(R.id.dock_divider));
3519        final ImageView scrollIndicator = getScrollingIndicator();
3520
3521        cancelScrollingIndicatorAnimations();
3522        dockDivider.setAlpha(reducedFade);
3523        scrollIndicator.setAlpha(1 - fade);
3524    }
3525}
3526