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