Launcher.java revision 2313eff05b8f52e72ebe06c589c419941fa019d6 
1
2/*
3 * Copyright (C) 2008 The Android Open Source Project
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18package com.android.launcher2;
19
20import com.android.common.Search;
21import com.android.launcher.R;
22import com.android.launcher2.CustomizePagedView.CustomizationType;
23import com.android.launcher2.Workspace.ShrinkState;
24
25import android.animation.Animator;
26import android.animation.AnimatorListenerAdapter;
27import android.animation.AnimatorSet;
28import android.animation.ObjectAnimator;
29import android.animation.PropertyValuesHolder;
30import android.animation.TimeInterpolator;
31import android.animation.ValueAnimator;
32import android.app.Activity;
33import android.app.AlertDialog;
34import android.app.Dialog;
35import android.app.SearchManager;
36import android.app.StatusBarManager;
37import android.appwidget.AppWidgetManager;
38import android.appwidget.AppWidgetProviderInfo;
39import android.content.ActivityNotFoundException;
40import android.content.BroadcastReceiver;
41import android.content.ClipData;
42import android.content.ClipDescription;
43import android.content.ComponentName;
44import android.content.ContentResolver;
45import android.content.Context;
46import android.content.DialogInterface;
47import android.content.Intent;
48import android.content.IntentFilter;
49import android.content.Intent.ShortcutIconResource;
50import android.content.pm.ActivityInfo;
51import android.content.pm.PackageManager;
52import android.content.pm.ResolveInfo;
53import android.content.pm.PackageManager.NameNotFoundException;
54import android.content.res.Configuration;
55import android.content.res.Resources;
56import android.content.res.TypedArray;
57import android.database.ContentObserver;
58import android.graphics.Bitmap;
59import android.graphics.Canvas;
60import android.graphics.Rect;
61import android.graphics.drawable.ColorDrawable;
62import android.graphics.drawable.Drawable;
63import android.net.Uri;
64import android.os.AsyncTask;
65import android.os.Bundle;
66import android.os.Environment;
67import android.os.Handler;
68import android.os.Message;
69import android.os.Parcelable;
70import android.os.SystemClock;
71import android.os.SystemProperties;
72import android.provider.LiveFolders;
73import android.provider.Settings;
74import android.speech.RecognizerIntent;
75import android.text.Selection;
76import android.text.SpannableStringBuilder;
77import android.text.TextUtils;
78import android.text.method.TextKeyListener;
79import android.util.Log;
80import android.view.HapticFeedbackConstants;
81import android.view.KeyEvent;
82import android.view.LayoutInflater;
83import android.view.Menu;
84import android.view.MenuItem;
85import android.view.MotionEvent;
86import android.view.View;
87import android.view.ViewGroup;
88import android.view.WindowManager;
89import android.view.View.OnLongClickListener;
90import android.view.accessibility.AccessibilityEvent;
91import android.view.animation.DecelerateInterpolator;
92import android.view.inputmethod.InputMethodManager;
93import android.widget.Advanceable;
94import android.widget.EditText;
95import android.widget.ImageView;
96import android.widget.LinearLayout;
97import android.widget.PopupWindow;
98import android.widget.TabHost;
99import android.widget.TabWidget;
100import android.widget.TextView;
101import android.widget.Toast;
102import android.widget.TabHost.OnTabChangeListener;
103import android.widget.TabHost.TabContentFactory;
104
105import java.io.DataInputStream;
106import java.io.DataOutputStream;
107import java.io.FileNotFoundException;
108import java.io.IOException;
109import java.lang.ref.WeakReference;
110import java.util.ArrayList;
111import java.util.HashMap;
112import java.util.List;
113
114
115/**
116 * Default launcher application.
117 */
118public final class Launcher extends Activity
119        implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks,
120                   AllAppsView.Watcher, View.OnTouchListener {
121    static final String TAG = "Launcher";
122    static final boolean LOGD = false;
123
124    static final boolean PROFILE_STARTUP = false;
125    static final boolean DEBUG_WIDGETS = false;
126    static final boolean DEBUG_USER_INTERFACE = false;
127
128    private static final int MENU_GROUP_ADD = 1;
129    private static final int MENU_GROUP_WALLPAPER = MENU_GROUP_ADD + 1;
130
131    private static final int MENU_ADD = Menu.FIRST + 1;
132    private static final int MENU_MANAGE_APPS = MENU_ADD + 1;
133    private static final int MENU_WALLPAPER_SETTINGS = MENU_MANAGE_APPS + 1;
134    private static final int MENU_SEARCH = MENU_WALLPAPER_SETTINGS + 1;
135    private static final int MENU_NOTIFICATIONS = MENU_SEARCH + 1;
136    private static final int MENU_SETTINGS = MENU_NOTIFICATIONS + 1;
137
138    private static final int REQUEST_CREATE_SHORTCUT = 1;
139    private static final int REQUEST_CREATE_LIVE_FOLDER = 4;
140    private static final int REQUEST_CREATE_APPWIDGET = 5;
141    private static final int REQUEST_PICK_APPLICATION = 6;
142    private static final int REQUEST_PICK_SHORTCUT = 7;
143    private static final int REQUEST_PICK_LIVE_FOLDER = 8;
144    private static final int REQUEST_PICK_APPWIDGET = 9;
145    private static final int REQUEST_PICK_WALLPAPER = 10;
146
147    static final String EXTRA_SHORTCUT_DUPLICATE = "duplicate";
148
149    static final int SCREEN_COUNT = 5;
150    static final int DEFAULT_SCREEN = 2;
151
152    static final int DIALOG_CREATE_SHORTCUT = 1;
153    static final int DIALOG_RENAME_FOLDER = 2;
154
155    private static final String PREFERENCES = "launcher.preferences";
156
157    // Type: int
158    private static final String RUNTIME_STATE_CURRENT_SCREEN = "launcher.current_screen";
159    // Type: int
160    private static final String RUNTIME_STATE = "launcher.state";
161    // Type: long
162    private static final String RUNTIME_STATE_USER_FOLDERS = "launcher.user_folder";
163    // Type: int
164    private static final String RUNTIME_STATE_PENDING_ADD_SCREEN = "launcher.add_screen";
165    // Type: int
166    private static final String RUNTIME_STATE_PENDING_ADD_CELL_X = "launcher.add_cellX";
167    // Type: int
168    private static final String RUNTIME_STATE_PENDING_ADD_CELL_Y = "launcher.add_cellY";
169    // Type: boolean
170    private static final String RUNTIME_STATE_PENDING_FOLDER_RENAME = "launcher.rename_folder";
171    // Type: long
172    private static final String RUNTIME_STATE_PENDING_FOLDER_RENAME_ID = "launcher.rename_folder_id";
173
174    // tags for the customization tabs
175    private static final String WIDGETS_TAG = "widgets";
176    private static final String APPLICATIONS_TAG = "applications";
177    private static final String SHORTCUTS_TAG = "shortcuts";
178    private static final String WALLPAPERS_TAG = "wallpapers";
179
180    private static final String TOOLBAR_ICON_METADATA_NAME = "com.android.launcher.toolbar_icon";
181
182    /** The different states that Launcher can be in. */
183    private enum State { WORKSPACE, ALL_APPS, CUSTOMIZE, OVERVIEW,
184        CUSTOMIZE_SPRING_LOADED, ALL_APPS_SPRING_LOADED };
185    private State mState = State.WORKSPACE;
186    private AnimatorSet mStateAnimation;
187
188    static final int APPWIDGET_HOST_ID = 1024;
189
190    private static final Object sLock = new Object();
191    private static int sScreen = DEFAULT_SCREEN;
192
193    private final BroadcastReceiver mCloseSystemDialogsReceiver
194            = new CloseSystemDialogsIntentReceiver();
195    private final ContentObserver mWidgetObserver = new AppWidgetResetObserver();
196
197    private LayoutInflater mInflater;
198
199    private DragController mDragController;
200    private Workspace mWorkspace;
201
202    private AppWidgetManager mAppWidgetManager;
203    private LauncherAppWidgetHost mAppWidgetHost;
204
205    private int mAddScreen = -1;
206    private int mAddIntersectCellX = -1;
207    private int mAddIntersectCellY = -1;
208    private int[] mAddDropPosition;
209    private int[] mTmpAddItemCellCoordinates = new int[2];
210
211    private FolderInfo mFolderInfo;
212
213    private DeleteZone mDeleteZone;
214    private HandleView mHandleView;
215    private AllAppsView mAllAppsGrid;
216    private TabHost mHomeCustomizationDrawer;
217    private boolean mAutoAdvanceRunning = false;
218
219    private AllAppsPagedView mAllAppsPagedView = null;
220    private CustomizePagedView mCustomizePagedView = null;
221
222    private Bundle mSavedState;
223
224    private SpannableStringBuilder mDefaultKeySsb = null;
225
226    private boolean mWorkspaceLoading = true;
227
228    private boolean mPaused = true;
229    private boolean mRestoring;
230    private boolean mWaitingForResult;
231    private boolean mOnResumeNeedsLoad;
232
233    private Bundle mSavedInstanceState;
234
235    private LauncherModel mModel;
236    private IconCache mIconCache;
237    private boolean mUserPresent = true;
238    private boolean mVisible = false;
239    private boolean mAttached = false;
240
241    private static LocaleConfiguration sLocaleConfiguration = null;
242
243    private ArrayList<ItemInfo> mDesktopItems = new ArrayList<ItemInfo>();
244
245    private static HashMap<Long, FolderInfo> sFolders = new HashMap<Long, FolderInfo>();
246
247    private ImageView mPreviousView;
248    private ImageView mNextView;
249
250    // Hotseats (quick-launch icons next to AllApps)
251    private String[] mHotseatConfig = null;
252    private Intent[] mHotseats = null;
253    private Drawable[] mHotseatIcons = null;
254    private CharSequence[] mHotseatLabels = null;
255
256    private Intent mAppMarketIntent = null;
257
258    // Related to the auto-advancing of widgets
259    private final int ADVANCE_MSG = 1;
260    private final int mAdvanceInterval = 20000;
261    private final int mAdvanceStagger = 250;
262    private long mAutoAdvanceSentTime;
263    private long mAutoAdvanceTimeLeft = -1;
264    private HashMap<View, AppWidgetProviderInfo> mWidgetsToAdvance =
265        new HashMap<View, AppWidgetProviderInfo>();
266
267    // External icons saved in case of resource changes, orientation, etc.
268    private static Drawable.ConstantState sGlobalSearchIcon;
269    private static Drawable.ConstantState sVoiceSearchIcon;
270    private static Drawable.ConstantState sAppMarketIcon;
271
272    private CustomizationType getCustomizeFilterForTabTag(String tag) {
273        if (tag.equals(WIDGETS_TAG)) {
274            return CustomizationType.WidgetCustomization;
275        } else if (tag.equals(APPLICATIONS_TAG)) {
276            return CustomizationType.ApplicationCustomization;
277        } else if (tag.equals(WALLPAPERS_TAG)) {
278            return CustomizePagedView.CustomizationType.WallpaperCustomization;
279        } else if (tag.equals(SHORTCUTS_TAG)) {
280            return CustomizePagedView.CustomizationType.ShortcutCustomization;
281        }
282        return CustomizationType.WidgetCustomization;
283    }
284
285    @Override
286    protected void onCreate(Bundle savedInstanceState) {
287        super.onCreate(savedInstanceState);
288
289        if (LauncherApplication.isInPlaceRotationEnabled()) {
290            // hide the status bar (temporary until we get the status bar design figured out)
291            getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
292            this.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);
293        }
294
295        LauncherApplication app = ((LauncherApplication)getApplication());
296        mModel = app.setLauncher(this);
297        mIconCache = app.getIconCache();
298        mDragController = new DragController(this);
299        mInflater = getLayoutInflater();
300
301        mAppWidgetManager = AppWidgetManager.getInstance(this);
302        mAppWidgetHost = new LauncherAppWidgetHost(this, APPWIDGET_HOST_ID);
303        mAppWidgetHost.startListening();
304
305        if (PROFILE_STARTUP) {
306            android.os.Debug.startMethodTracing(
307                    Environment.getExternalStorageDirectory() + "/launcher");
308        }
309
310        loadHotseats();
311        checkForLocaleChange();
312        setContentView(R.layout.launcher);
313        mHomeCustomizationDrawer = (TabHost) findViewById(R.id.customization_drawer);
314        if (mHomeCustomizationDrawer != null) {
315            mHomeCustomizationDrawer.setup();
316
317            // share the same customization workspace across all the tabs
318            mCustomizePagedView = (CustomizePagedView) mInflater.inflate(
319                    R.layout.customization_drawer, mHomeCustomizationDrawer, false);
320            TabContentFactory contentFactory = new TabContentFactory() {
321                public View createTabContent(String tag) {
322                    return mCustomizePagedView;
323                }
324            };
325
326
327            TextView tabView;
328            TabWidget tabWidget = (TabWidget)
329                    mHomeCustomizationDrawer.findViewById(com.android.internal.R.id.tabs);
330
331            tabView = (TextView) mInflater.inflate(R.layout.tab_widget_indicator, tabWidget, false);
332            tabView.setText(getString(R.string.widgets_tab_label));
333            mHomeCustomizationDrawer.addTab(mHomeCustomizationDrawer.newTabSpec(WIDGETS_TAG)
334                    .setIndicator(tabView).setContent(contentFactory));
335            tabView = (TextView) mInflater.inflate(R.layout.tab_widget_indicator, tabWidget, false);
336            tabView.setText(getString(R.string.applications_tab_label));
337            mHomeCustomizationDrawer.addTab(mHomeCustomizationDrawer.newTabSpec(APPLICATIONS_TAG)
338                    .setIndicator(tabView).setContent(contentFactory));
339            tabView = (TextView) mInflater.inflate(R.layout.tab_widget_indicator, tabWidget, false);
340            tabView.setText(getString(R.string.wallpapers_tab_label));
341            mHomeCustomizationDrawer.addTab(mHomeCustomizationDrawer.newTabSpec(WALLPAPERS_TAG)
342                    .setIndicator(tabView).setContent(contentFactory));
343            tabView = (TextView) mInflater.inflate(R.layout.tab_widget_indicator, tabWidget, false);
344            tabView.setText(getString(R.string.shortcuts_tab_label));
345            mHomeCustomizationDrawer.addTab(mHomeCustomizationDrawer.newTabSpec(SHORTCUTS_TAG)
346                    .setIndicator(tabView).setContent(contentFactory));
347            mHomeCustomizationDrawer.setOnTabChangedListener(new OnTabChangeListener() {
348                public void onTabChanged(String tabId) {
349                    final CustomizePagedView.CustomizationType newType =
350                        getCustomizeFilterForTabTag(tabId);
351                    if (newType != mCustomizePagedView.getCustomizationFilter()) {
352                        // animate the changing of the tab content by fading pages in and out
353                        final Resources res = getResources();
354                        final int duration = res.getInteger(R.integer.config_tabTransitionTime);
355                        final float alpha = mCustomizePagedView.getAlpha();
356                        ValueAnimator alphaAnim = ObjectAnimator.ofFloat(mCustomizePagedView,
357                                "alpha", alpha, 0.0f);
358                        alphaAnim.setDuration(duration);
359                        alphaAnim.addListener(new AnimatorListenerAdapter() {
360                            @Override
361                            public void onAnimationEnd(Animator animation) {
362                                String tag = mHomeCustomizationDrawer.getCurrentTabTag();
363                                mCustomizePagedView.setCustomizationFilter(newType);
364
365                                final float alpha = mCustomizePagedView.getAlpha();
366                                ValueAnimator alphaAnim = ObjectAnimator.ofFloat(
367                                        mCustomizePagedView, "alpha", alpha, 1.0f);
368                                alphaAnim.setDuration(duration);
369                                alphaAnim.start();
370                            }
371                        });
372                        alphaAnim.start();
373                    }
374                }
375            });
376        }
377        setupViews();
378
379        registerContentObservers();
380
381        lockAllApps();
382
383        mSavedState = savedInstanceState;
384        restoreState(mSavedState);
385
386        // Update customization drawer _after_ restoring the states
387        if (mCustomizePagedView != null) {
388            mCustomizePagedView.update();
389        }
390
391        if (PROFILE_STARTUP) {
392            android.os.Debug.stopMethodTracing();
393        }
394
395        if (!mRestoring) {
396            mModel.startLoader(this, true);
397        }
398
399        // For handling default keys
400        mDefaultKeySsb = new SpannableStringBuilder();
401        Selection.setSelection(mDefaultKeySsb, 0);
402
403        IntentFilter filter = new IntentFilter(Intent.ACTION_CLOSE_SYSTEM_DIALOGS);
404        registerReceiver(mCloseSystemDialogsReceiver, filter);
405
406        // If we have a saved version of these external icons, we load them up immediately
407        if (LauncherApplication.isScreenXLarge()) {
408            if (sGlobalSearchIcon != null) {
409                updateGlobalSearchIcon(sGlobalSearchIcon);
410            }
411            if (sVoiceSearchIcon != null) {
412                updateVoiceSearchIcon(sVoiceSearchIcon);
413            }
414            if (sAppMarketIcon != null) {
415                updateAppMarketIcon(sAppMarketIcon);
416            }
417        }
418    }
419
420    @Override
421    public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
422        super.dispatchPopulateAccessibilityEvent(event);
423
424        // we want to take over text population so it is context dependent
425        event.getText().clear();
426        if (mState == State.ALL_APPS) {
427            event.getText().add(getString(R.string.all_apps_button_label));
428        } else if (mState == State.WORKSPACE) {
429            event.getText().add(getString(R.string.all_apps_home_button_label));
430        }
431
432        return true;
433    }
434
435    private void checkForLocaleChange() {
436        if (sLocaleConfiguration == null) {
437            new AsyncTask<Void, Void, LocaleConfiguration>() {
438                @Override
439                protected LocaleConfiguration doInBackground(Void... unused) {
440                    LocaleConfiguration localeConfiguration = new LocaleConfiguration();
441                    readConfiguration(Launcher.this, localeConfiguration);
442                    return localeConfiguration;
443                }
444
445                @Override
446                protected void onPostExecute(LocaleConfiguration result) {
447                    sLocaleConfiguration = result;
448                    checkForLocaleChange();  // recursive, but now with a locale configuration
449                }
450            }.execute();
451            return;
452        }
453
454        final Configuration configuration = getResources().getConfiguration();
455
456        final String previousLocale = sLocaleConfiguration.locale;
457        final String locale = configuration.locale.toString();
458
459        final int previousMcc = sLocaleConfiguration.mcc;
460        final int mcc = configuration.mcc;
461
462        final int previousMnc = sLocaleConfiguration.mnc;
463        final int mnc = configuration.mnc;
464
465        boolean localeChanged = !locale.equals(previousLocale) || mcc != previousMcc || mnc != previousMnc;
466
467        if (localeChanged) {
468            sLocaleConfiguration.locale = locale;
469            sLocaleConfiguration.mcc = mcc;
470            sLocaleConfiguration.mnc = mnc;
471
472            mIconCache.flush();
473            loadHotseats();
474
475            final LocaleConfiguration localeConfiguration = sLocaleConfiguration;
476            new Thread("WriteLocaleConfiguration") {
477                @Override
478                public void run() {
479                    writeConfiguration(Launcher.this, localeConfiguration);
480                }
481            }.start();
482        }
483    }
484
485    private static class LocaleConfiguration {
486        public String locale;
487        public int mcc = -1;
488        public int mnc = -1;
489    }
490
491    private static void readConfiguration(Context context, LocaleConfiguration configuration) {
492        DataInputStream in = null;
493        try {
494            in = new DataInputStream(context.openFileInput(PREFERENCES));
495            configuration.locale = in.readUTF();
496            configuration.mcc = in.readInt();
497            configuration.mnc = in.readInt();
498        } catch (FileNotFoundException e) {
499            // Ignore
500        } catch (IOException e) {
501            // Ignore
502        } finally {
503            if (in != null) {
504                try {
505                    in.close();
506                } catch (IOException e) {
507                    // Ignore
508                }
509            }
510        }
511    }
512
513    private static void writeConfiguration(Context context, LocaleConfiguration configuration) {
514        DataOutputStream out = null;
515        try {
516            out = new DataOutputStream(context.openFileOutput(PREFERENCES, MODE_PRIVATE));
517            out.writeUTF(configuration.locale);
518            out.writeInt(configuration.mcc);
519            out.writeInt(configuration.mnc);
520            out.flush();
521        } catch (FileNotFoundException e) {
522            // Ignore
523        } catch (IOException e) {
524            //noinspection ResultOfMethodCallIgnored
525            context.getFileStreamPath(PREFERENCES).delete();
526        } finally {
527            if (out != null) {
528                try {
529                    out.close();
530                } catch (IOException e) {
531                    // Ignore
532                }
533            }
534        }
535    }
536
537    static int getScreen() {
538        synchronized (sLock) {
539            return sScreen;
540        }
541    }
542
543    static void setScreen(int screen) {
544        synchronized (sLock) {
545            sScreen = screen;
546        }
547    }
548
549    // Note: This doesn't do all the client-id magic that BrowserProvider does
550    // in Browser. (http://b/2425179)
551    private Uri getDefaultBrowserUri() {
552        String url = getString(R.string.default_browser_url);
553        if (url.indexOf("{CID}") != -1) {
554            url = url.replace("{CID}", "android-google");
555        }
556        return Uri.parse(url);
557    }
558
559    // Load the Intent templates from arrays.xml to populate the hotseats. For
560    // each Intent, if it resolves to a single app, use that as the launch
561    // intent & use that app's label as the contentDescription. Otherwise,
562    // retain the ResolveActivity so the user can pick an app.
563    private void loadHotseats() {
564        if (mHotseatConfig == null) {
565            mHotseatConfig = getResources().getStringArray(R.array.hotseats);
566            if (mHotseatConfig.length > 0) {
567                mHotseats = new Intent[mHotseatConfig.length];
568                mHotseatLabels = new CharSequence[mHotseatConfig.length];
569                mHotseatIcons = new Drawable[mHotseatConfig.length];
570            } else {
571                mHotseats = null;
572                mHotseatIcons = null;
573                mHotseatLabels = null;
574            }
575
576            TypedArray hotseatIconDrawables = getResources().obtainTypedArray(R.array.hotseat_icons);
577            for (int i=0; i<mHotseatConfig.length; i++) {
578                // load icon for this slot; currently unrelated to the actual activity
579                try {
580                    mHotseatIcons[i] = hotseatIconDrawables.getDrawable(i);
581                } catch (ArrayIndexOutOfBoundsException ex) {
582                    Log.w(TAG, "Missing hotseat_icons array item #" + i);
583                    mHotseatIcons[i] = null;
584                }
585            }
586            hotseatIconDrawables.recycle();
587        }
588
589        PackageManager pm = getPackageManager();
590        for (int i=0; i<mHotseatConfig.length; i++) {
591            Intent intent = null;
592            if (mHotseatConfig[i].equals("*BROWSER*")) {
593                // magic value meaning "launch user's default web browser"
594                // replace it with a generic web request so we can see if there is indeed a default
595                String defaultUri = getString(R.string.default_browser_url);
596                intent = new Intent(
597                        Intent.ACTION_VIEW,
598                        ((defaultUri != null)
599                            ? Uri.parse(defaultUri)
600                            : getDefaultBrowserUri())
601                    ).addCategory(Intent.CATEGORY_BROWSABLE);
602                // note: if the user launches this without a default set, she
603                // will always be taken to the default URL above; this is
604                // unavoidable as we must specify a valid URL in order for the
605                // chooser to appear, and once the user selects something, that
606                // URL is unavoidably sent to the chosen app.
607            } else {
608                try {
609                    intent = Intent.parseUri(mHotseatConfig[i], 0);
610                } catch (java.net.URISyntaxException ex) {
611                    Log.w(TAG, "Invalid hotseat intent: " + mHotseatConfig[i]);
612                    // bogus; leave intent=null
613                }
614            }
615
616            if (intent == null) {
617                mHotseats[i] = null;
618                mHotseatLabels[i] = getText(R.string.activity_not_found);
619                continue;
620            }
621
622            if (LOGD) {
623                Log.d(TAG, "loadHotseats: hotseat " + i
624                    + " initial intent=["
625                    + intent.toUri(Intent.URI_INTENT_SCHEME)
626                    + "]");
627            }
628
629            ResolveInfo bestMatch = pm.resolveActivity(intent, PackageManager.MATCH_DEFAULT_ONLY);
630            List<ResolveInfo> allMatches = pm.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
631            if (LOGD) {
632                Log.d(TAG, "Best match for intent: " + bestMatch);
633                Log.d(TAG, "All matches: ");
634                for (ResolveInfo ri : allMatches) {
635                    Log.d(TAG, "  --> " + ri);
636                }
637            }
638            // did this resolve to a single app, or the resolver?
639            if (allMatches.size() == 0 || bestMatch == null) {
640                // can't find any activity to handle this. let's leave the
641                // intent as-is and let Launcher show a toast when it fails
642                // to launch.
643                mHotseats[i] = intent;
644
645                // set accessibility text to "Not installed"
646                mHotseatLabels[i] = getText(R.string.activity_not_found);
647            } else {
648                boolean found = false;
649                for (ResolveInfo ri : allMatches) {
650                    if (bestMatch.activityInfo.name.equals(ri.activityInfo.name)
651                        && bestMatch.activityInfo.applicationInfo.packageName
652                            .equals(ri.activityInfo.applicationInfo.packageName)) {
653                        found = true;
654                        break;
655                    }
656                }
657
658                if (!found) {
659                    if (LOGD) Log.d(TAG, "Multiple options, no default yet");
660                    // the bestMatch is probably the ResolveActivity, meaning the
661                    // user has not yet selected a default
662                    // so: we'll keep the original intent for now
663                    mHotseats[i] = intent;
664
665                    // set the accessibility text to "Select shortcut"
666                    mHotseatLabels[i] = getText(R.string.title_select_shortcut);
667                } else {
668                    // we have an app!
669                    // now reconstruct the intent to launch it through the front
670                    // door
671                    ComponentName com = new ComponentName(
672                        bestMatch.activityInfo.applicationInfo.packageName,
673                        bestMatch.activityInfo.name);
674                    mHotseats[i] = new Intent(Intent.ACTION_MAIN).setComponent(com);
675
676                    // load the app label for accessibility
677                    mHotseatLabels[i] = bestMatch.activityInfo.loadLabel(pm);
678                }
679            }
680
681            if (LOGD) {
682                Log.d(TAG, "loadHotseats: hotseat " + i
683                    + " final intent=["
684                    + ((mHotseats[i] == null)
685                        ? "null"
686                        : mHotseats[i].toUri(Intent.URI_INTENT_SCHEME))
687                    + "] label=[" + mHotseatLabels[i]
688                    + "]"
689                    );
690            }
691        }
692    }
693
694    @Override
695    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
696        mWaitingForResult = false;
697
698        // The pattern used here is that a user PICKs a specific application,
699        // which, depending on the target, might need to CREATE the actual target.
700
701        // For example, the user would PICK_SHORTCUT for "Music playlist", and we
702        // launch over to the Music app to actually CREATE_SHORTCUT.
703
704        if (resultCode == RESULT_OK && mAddScreen != -1) {
705            switch (requestCode) {
706                case REQUEST_PICK_APPLICATION:
707                    completeAddApplication(
708                            this, data, mAddScreen, mAddIntersectCellX, mAddIntersectCellY);
709                    break;
710                case REQUEST_PICK_SHORTCUT:
711                    processShortcut(data);
712                    break;
713                case REQUEST_CREATE_SHORTCUT:
714                    completeAddShortcut(data, mAddScreen, mAddIntersectCellX, mAddIntersectCellY);
715                    break;
716                case REQUEST_PICK_LIVE_FOLDER:
717                    addLiveFolder(data);
718                    break;
719                case REQUEST_CREATE_LIVE_FOLDER:
720                    completeAddLiveFolder(data, mAddScreen, mAddIntersectCellX, mAddIntersectCellY);
721                    break;
722                case REQUEST_PICK_APPWIDGET:
723                    addAppWidgetFromPick(data);
724                    break;
725                case REQUEST_CREATE_APPWIDGET:
726                    int appWidgetId = data.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1);
727                    completeAddAppWidget(appWidgetId, mAddScreen);
728                    break;
729                case REQUEST_PICK_WALLPAPER:
730                    // We just wanted the activity result here so we can clear mWaitingForResult
731                    break;
732            }
733        } else if ((requestCode == REQUEST_PICK_APPWIDGET ||
734                requestCode == REQUEST_CREATE_APPWIDGET) && resultCode == RESULT_CANCELED &&
735                data != null) {
736            // Clean up the appWidgetId if we canceled
737            int appWidgetId = data.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1);
738            if (appWidgetId != -1) {
739                mAppWidgetHost.deleteAppWidgetId(appWidgetId);
740            }
741        }
742    }
743
744    @Override
745    protected void onResume() {
746        super.onResume();
747        mPaused = false;
748        if (mRestoring || mOnResumeNeedsLoad) {
749            mWorkspaceLoading = true;
750            mModel.startLoader(this, true);
751            mRestoring = false;
752            mOnResumeNeedsLoad = false;
753        }
754        // When we resume Launcher, a different Activity might be responsible for the app
755        // market intent, so refresh the icon
756        updateAppMarketIcon();
757    }
758
759    @Override
760    protected void onPause() {
761        super.onPause();
762        // Some launcher layouts don't have a previous and next view
763        if (mPreviousView != null) {
764            dismissPreview(mPreviousView);
765        }
766        if (mNextView != null) {
767            dismissPreview(mNextView);
768        }
769        mPaused = true;
770        mDragController.cancelDrag();
771    }
772
773    @Override
774    public Object onRetainNonConfigurationInstance() {
775        // Flag the loader to stop early before switching
776        mModel.stopLoader();
777        mAllAppsGrid.surrender();
778        return Boolean.TRUE;
779    }
780
781    // We can't hide the IME if it was forced open.  So don't bother
782    /*
783    @Override
784    public void onWindowFocusChanged(boolean hasFocus) {
785        super.onWindowFocusChanged(hasFocus);
786
787        if (hasFocus) {
788            final InputMethodManager inputManager = (InputMethodManager)
789                    getSystemService(Context.INPUT_METHOD_SERVICE);
790            WindowManager.LayoutParams lp = getWindow().getAttributes();
791            inputManager.hideSoftInputFromWindow(lp.token, 0, new android.os.ResultReceiver(new
792                        android.os.Handler()) {
793                        protected void onReceiveResult(int resultCode, Bundle resultData) {
794                            Log.d(TAG, "ResultReceiver got resultCode=" + resultCode);
795                        }
796                    });
797            Log.d(TAG, "called hideSoftInputFromWindow from onWindowFocusChanged");
798        }
799    }
800    */
801
802    private boolean acceptFilter() {
803        final InputMethodManager inputManager = (InputMethodManager)
804                getSystemService(Context.INPUT_METHOD_SERVICE);
805        return !inputManager.isFullscreenMode();
806    }
807
808    @Override
809    public boolean onKeyDown(int keyCode, KeyEvent event) {
810        boolean handled = super.onKeyDown(keyCode, event);
811        if (!handled && acceptFilter() && keyCode != KeyEvent.KEYCODE_ENTER) {
812            boolean gotKey = TextKeyListener.getInstance().onKeyDown(mWorkspace, mDefaultKeySsb,
813                    keyCode, event);
814            if (gotKey && mDefaultKeySsb != null && mDefaultKeySsb.length() > 0) {
815                // something usable has been typed - start a search
816                // the typed text will be retrieved and cleared by
817                // showSearchDialog()
818                // If there are multiple keystrokes before the search dialog takes focus,
819                // onSearchRequested() will be called for every keystroke,
820                // but it is idempotent, so it's fine.
821                return onSearchRequested();
822            }
823        }
824
825        // Eat the long press event so the keyboard doesn't come up.
826        if (keyCode == KeyEvent.KEYCODE_MENU && event.isLongPress()) {
827            return true;
828        }
829
830        return handled;
831    }
832
833    private String getTypedText() {
834        return mDefaultKeySsb.toString();
835    }
836
837    private void clearTypedText() {
838        mDefaultKeySsb.clear();
839        mDefaultKeySsb.clearSpans();
840        Selection.setSelection(mDefaultKeySsb, 0);
841    }
842
843    /**
844     * Given the integer (ordinal) value of a State enum instance, convert it to a variable of type
845     * State
846     */
847    private static State intToState(int stateOrdinal) {
848        State state = State.WORKSPACE;
849        final State[] stateValues = State.values();
850        for (int i = 0; i < stateValues.length; i++) {
851            if (stateValues[i].ordinal() == stateOrdinal) {
852                state = stateValues[i];
853                break;
854            }
855        }
856        return state;
857    }
858
859    /**
860     * Restores the previous state, if it exists.
861     *
862     * @param savedState The previous state.
863     */
864    private void restoreState(Bundle savedState) {
865        if (savedState == null) {
866            return;
867        }
868
869        State state = intToState(savedState.getInt(RUNTIME_STATE, State.WORKSPACE.ordinal()));
870
871        if (state == State.ALL_APPS) {
872            showAllApps(false);
873        } else if (state == State.CUSTOMIZE) {
874            showCustomizationDrawer(false);
875        }
876
877        final int currentScreen = savedState.getInt(RUNTIME_STATE_CURRENT_SCREEN, -1);
878        if (currentScreen > -1) {
879            mWorkspace.setCurrentPage(currentScreen);
880        }
881
882        final int addScreen = savedState.getInt(RUNTIME_STATE_PENDING_ADD_SCREEN, -1);
883
884        if (addScreen > -1) {
885            mAddScreen = addScreen;
886            mAddIntersectCellX = savedState.getInt(RUNTIME_STATE_PENDING_ADD_CELL_X);
887            mAddIntersectCellY = savedState.getInt(RUNTIME_STATE_PENDING_ADD_CELL_Y);
888            mRestoring = true;
889        }
890
891        boolean renameFolder = savedState.getBoolean(RUNTIME_STATE_PENDING_FOLDER_RENAME, false);
892        if (renameFolder) {
893            long id = savedState.getLong(RUNTIME_STATE_PENDING_FOLDER_RENAME_ID);
894            mFolderInfo = mModel.getFolderById(this, sFolders, id);
895            mRestoring = true;
896        }
897
898        // Restore the current AllApps drawer tab
899        if (mAllAppsGrid != null && mAllAppsGrid instanceof AllAppsTabbed) {
900            String curTab = savedState.getString("allapps_currentTab");
901            if (curTab != null) {
902                AllAppsTabbed tabhost = (AllAppsTabbed) mAllAppsGrid;
903                tabhost.setCurrentTabByTag(curTab);
904            }
905            int curPage = savedState.getInt("allapps_currentPage", -1);
906            if (curPage > -1) {
907                mAllAppsPagedView.setRestorePage(curPage);
908            }
909        }
910
911        // Restore the current customization drawer tab
912        if (mHomeCustomizationDrawer != null) {
913            String curTab = savedState.getString("customize_currentTab");
914            if (curTab != null) {
915                // We set this directly so that there is no delay before the tab is set
916                mCustomizePagedView.setCustomizationFilter(getCustomizeFilterForTabTag(curTab));
917                mHomeCustomizationDrawer.setCurrentTabByTag(curTab);
918            }
919
920            // Note: currently we do not restore the page for the customization tray because unlike
921            // AllApps, the page content can change drastically
922        }
923    }
924
925    /**
926     * Finds all the views we need and configure them properly.
927     */
928    private void setupViews() {
929        final DragController dragController = mDragController;
930
931        DragLayer dragLayer = (DragLayer) findViewById(R.id.drag_layer);
932        dragLayer.setDragController(dragController);
933
934        mAllAppsGrid = (AllAppsView)dragLayer.findViewById(R.id.all_apps_view);
935        mAllAppsGrid.setLauncher(this);
936        mAllAppsGrid.setDragController(dragController);
937        ((View) mAllAppsGrid).setWillNotDraw(false); // We don't want a hole punched in our window.
938        // Manage focusability manually since this thing is always visible (in non-xlarge)
939        ((View) mAllAppsGrid).setFocusable(false);
940
941        if (LauncherApplication.isScreenXLarge()) {
942            // They need to be INVISIBLE initially so that they will be measured in the layout.
943            // Otherwise the animations are messed up when we show them for the first time.
944            ((View) mAllAppsGrid).setVisibility(View.INVISIBLE);
945            mHomeCustomizationDrawer.setVisibility(View.INVISIBLE);
946        }
947
948        mWorkspace = (Workspace) dragLayer.findViewById(R.id.workspace);
949
950        final Workspace workspace = mWorkspace;
951        workspace.setHapticFeedbackEnabled(false);
952
953        DeleteZone deleteZone = (DeleteZone) dragLayer.findViewById(R.id.delete_zone);
954        mDeleteZone = deleteZone;
955
956        View handleView = findViewById(R.id.all_apps_button);
957        if (handleView != null && handleView instanceof HandleView) {
958            // we don't use handle view in xlarge mode
959            mHandleView = (HandleView)handleView;
960            mHandleView.setLauncher(this);
961            mHandleView.setOnClickListener(this);
962            mHandleView.setOnLongClickListener(this);
963        }
964
965        if (mCustomizePagedView != null) {
966            mCustomizePagedView.setLauncher(this);
967            mCustomizePagedView.setDragController(dragController);
968        } else {
969             ImageView hotseatLeft = (ImageView) findViewById(R.id.hotseat_left);
970             hotseatLeft.setContentDescription(mHotseatLabels[0]);
971             hotseatLeft.setImageDrawable(mHotseatIcons[0]);
972             ImageView hotseatRight = (ImageView) findViewById(R.id.hotseat_right);
973             hotseatRight.setContentDescription(mHotseatLabels[1]);
974             hotseatRight.setImageDrawable(mHotseatIcons[1]);
975
976             mPreviousView = (ImageView) dragLayer.findViewById(R.id.previous_screen);
977             mNextView = (ImageView) dragLayer.findViewById(R.id.next_screen);
978
979             Drawable previous = mPreviousView.getDrawable();
980             Drawable next = mNextView.getDrawable();
981             mWorkspace.setIndicators(previous, next);
982
983             mPreviousView.setHapticFeedbackEnabled(false);
984             mPreviousView.setOnLongClickListener(this);
985             mNextView.setHapticFeedbackEnabled(false);
986             mNextView.setOnLongClickListener(this);
987        }
988
989        workspace.setOnLongClickListener(this);
990        workspace.setDragController(dragController);
991        workspace.setLauncher(this);
992        workspace.setWallpaperDimension();
993
994        deleteZone.setLauncher(this);
995        deleteZone.setDragController(dragController);
996        int deleteZoneHandleId;
997
998        final View allAppsButton = findViewById(R.id.all_apps_button);
999        final View divider = findViewById(R.id.divider);
1000        final View configureButton = findViewById(R.id.configure_button);
1001
1002        if (LauncherApplication.isScreenXLarge()) {
1003            deleteZone.setOverlappingViews(new View[] { allAppsButton, divider, configureButton });
1004        } else {
1005            deleteZone.setOverlappingView(findViewById(R.id.all_apps_button_cluster));
1006        }
1007        dragController.addDragListener(deleteZone);
1008
1009        DeleteZone allAppsDeleteZone = (DeleteZone) findViewById(R.id.all_apps_delete_zone);
1010        if (allAppsDeleteZone != null) {
1011            allAppsDeleteZone.setLauncher(this);
1012            allAppsDeleteZone.setDragController(dragController);
1013            allAppsDeleteZone.setDragAndDropEnabled(false);
1014            dragController.addDragListener(allAppsDeleteZone);
1015            dragController.addDropTarget(allAppsDeleteZone);
1016        }
1017
1018        ApplicationInfoDropTarget allAppsInfoTarget = (ApplicationInfoDropTarget)
1019                findViewById(R.id.all_apps_info_target);
1020        if (allAppsInfoTarget != null) {
1021            allAppsInfoTarget.setLauncher(this);
1022            dragController.addDragListener(allAppsInfoTarget);
1023            allAppsInfoTarget.setDragAndDropEnabled(false);
1024            View marketButton = findViewById(R.id.market_button);
1025            if (marketButton != null) {
1026                allAppsInfoTarget.setOverlappingView(marketButton);
1027            }
1028        }
1029
1030        dragController.setDragScoller(workspace);
1031        dragController.setScrollView(dragLayer);
1032        dragController.setMoveTarget(workspace);
1033
1034        // The order here is bottom to top.
1035        dragController.addDropTarget(workspace);
1036        dragController.addDropTarget(deleteZone);
1037        if (allAppsInfoTarget != null) {
1038            dragController.addDropTarget(allAppsInfoTarget);
1039        }
1040        if (allAppsDeleteZone != null) {
1041            dragController.addDropTarget(allAppsDeleteZone);
1042        }
1043    }
1044
1045    @SuppressWarnings({"UnusedDeclaration"})
1046    public void previousScreen(View v) {
1047        if (mState != State.ALL_APPS) {
1048            mWorkspace.scrollLeft();
1049        }
1050    }
1051
1052    @SuppressWarnings({"UnusedDeclaration"})
1053    public void nextScreen(View v) {
1054        if (mState != State.ALL_APPS) {
1055            mWorkspace.scrollRight();
1056        }
1057    }
1058
1059    @SuppressWarnings({"UnusedDeclaration"})
1060    public void launchHotSeat(View v) {
1061        if (mState == State.ALL_APPS) return;
1062
1063        int index = -1;
1064        if (v.getId() == R.id.hotseat_left) {
1065            index = 0;
1066        } else if (v.getId() == R.id.hotseat_right) {
1067            index = 1;
1068        }
1069
1070        // reload these every tap; you never know when they might change
1071        loadHotseats();
1072        if (index >= 0 && index < mHotseats.length && mHotseats[index] != null) {
1073            Intent intent = mHotseats[index];
1074            startActivitySafely(
1075                mHotseats[index],
1076                "hotseat"
1077            );
1078        }
1079    }
1080
1081    /**
1082     * Creates a view representing a shortcut.
1083     *
1084     * @param info The data structure describing the shortcut.
1085     *
1086     * @return A View inflated from R.layout.application.
1087     */
1088    View createShortcut(ShortcutInfo info) {
1089        return createShortcut(R.layout.application,
1090                (ViewGroup) mWorkspace.getChildAt(mWorkspace.getCurrentPage()), info);
1091    }
1092
1093    /**
1094     * Creates a view representing a shortcut inflated from the specified resource.
1095     *
1096     * @param layoutResId The id of the XML layout used to create the shortcut.
1097     * @param parent The group the shortcut belongs to.
1098     * @param info The data structure describing the shortcut.
1099     *
1100     * @return A View inflated from layoutResId.
1101     */
1102    View createShortcut(int layoutResId, ViewGroup parent, ShortcutInfo info) {
1103        BubbleTextView favorite = (BubbleTextView) mInflater.inflate(layoutResId, parent, false);
1104        favorite.applyFromShortcutInfo(info, mIconCache);
1105        favorite.setOnClickListener(this);
1106        return favorite;
1107    }
1108
1109    /**
1110     * Add an application shortcut to the workspace.
1111     *
1112     * @param data The intent describing the application.
1113     * @param cellInfo The position on screen where to create the shortcut.
1114     */
1115    void completeAddApplication(Context context, Intent data, int screen,
1116            int intersectCellX, int intersectCellY) {
1117        final int[] cellXY = mTmpAddItemCellCoordinates;
1118        final CellLayout layout = (CellLayout) mWorkspace.getChildAt(screen);
1119
1120        if (!layout.findCellForSpanThatIntersects(cellXY, 1, 1, intersectCellX, intersectCellY)) {
1121            showOutOfSpaceMessage();
1122            return;
1123        }
1124
1125        final ShortcutInfo info = mModel.getShortcutInfo(context.getPackageManager(),
1126                data, context);
1127
1128        if (info != null) {
1129            info.setActivity(data.getComponent(), Intent.FLAG_ACTIVITY_NEW_TASK |
1130                    Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
1131            info.container = ItemInfo.NO_ID;
1132            mWorkspace.addApplicationShortcut(info, screen, cellXY[0], cellXY[1],
1133                    isWorkspaceLocked(), mAddIntersectCellX, mAddIntersectCellY);
1134        } else {
1135            Log.e(TAG, "Couldn't find ActivityInfo for selected application: " + data);
1136        }
1137    }
1138
1139    /**
1140     * Add a shortcut to the workspace.
1141     *
1142     * @param data The intent describing the shortcut.
1143     * @param cellInfo The position on screen where to create the shortcut.
1144     */
1145    private void completeAddShortcut(Intent data, int screen,
1146            int intersectCellX, int intersectCellY) {
1147        final int[] cellXY = mTmpAddItemCellCoordinates;
1148        final CellLayout layout = (CellLayout) mWorkspace.getChildAt(screen);
1149
1150        int[] touchXY = null;
1151        if (mAddDropPosition != null && mAddDropPosition[0] > -1 && mAddDropPosition[1] > -1) {
1152            touchXY = mAddDropPosition;
1153        }
1154        boolean foundCellSpan = false;
1155        if (touchXY != null) {
1156            // when dragging and dropping, just find the closest free spot
1157            CellLayout screenLayout = (CellLayout) mWorkspace.getChildAt(screen);
1158            int[] result = screenLayout.findNearestVacantArea(
1159                    touchXY[0], touchXY[1], 1, 1, cellXY);
1160            foundCellSpan = (result != null);
1161        } else {
1162            foundCellSpan = layout.findCellForSpanThatIntersects(
1163                    cellXY, 1, 1, intersectCellX, intersectCellY);
1164        }
1165
1166        if (!foundCellSpan) {
1167            showOutOfSpaceMessage();
1168            return;
1169        }
1170
1171        final ShortcutInfo info = mModel.addShortcut(
1172                this, data, screen, cellXY[0], cellXY[1], false);
1173
1174        if (!mRestoring) {
1175            final View view = createShortcut(info);
1176            mWorkspace.addInScreen(view, screen, cellXY[0], cellXY[1], 1, 1, isWorkspaceLocked());
1177        }
1178    }
1179
1180    /**
1181     * Add a widget to the workspace.
1182     *
1183     * @param appWidgetId The app widget id
1184     * @param cellInfo The position on screen where to create the widget.
1185     */
1186    private void completeAddAppWidget(int appWidgetId, int screen) {
1187        AppWidgetProviderInfo appWidgetInfo = mAppWidgetManager.getAppWidgetInfo(appWidgetId);
1188
1189        // Calculate the grid spans needed to fit this widget
1190        CellLayout layout = (CellLayout) mWorkspace.getChildAt(screen);
1191        int[] spanXY = layout.rectToCell(appWidgetInfo.minWidth, appWidgetInfo.minHeight, null);
1192
1193        // Try finding open space on Launcher screen
1194        // We have saved the position to which the widget was dragged-- this really only matters
1195        // if we are placing widgets on a "spring-loaded" screen
1196        final int[] cellXY = mTmpAddItemCellCoordinates;
1197
1198        // For now, we don't save the coordinate where we dropped the icon because we're not
1199        // supporting spring-loaded mini-screens; however, leaving the ability to directly place
1200        // a widget on the home screen in case we want to add it in the future
1201        int[] touchXY = null;
1202        if (mAddDropPosition != null && mAddDropPosition[0] > -1 && mAddDropPosition[1] > -1) {
1203            touchXY = mAddDropPosition;
1204        }
1205        boolean foundCellSpan = false;
1206        if (touchXY != null) {
1207            // when dragging and dropping, just find the closest free spot
1208            CellLayout screenLayout = (CellLayout) mWorkspace.getChildAt(screen);
1209            int[] result = screenLayout.findNearestVacantArea(
1210                    touchXY[0], touchXY[1], spanXY[0], spanXY[1], cellXY);
1211            foundCellSpan = (result != null);
1212        } else {
1213            // if we long pressed on an empty cell to bring up a menu,
1214            // make sure we intersect the empty cell
1215            // if mAddIntersectCellX/Y are -1 (e.g. we used menu -> add) then
1216            // findCellForSpanThatIntersects will just ignore them
1217            foundCellSpan = layout.findCellForSpanThatIntersects(cellXY, spanXY[0], spanXY[1],
1218                    mAddIntersectCellX, mAddIntersectCellY);
1219        }
1220
1221        if (!foundCellSpan) {
1222            if (appWidgetId != -1) mAppWidgetHost.deleteAppWidgetId(appWidgetId);
1223            showOutOfSpaceMessage();
1224            return;
1225        }
1226
1227        // Build Launcher-specific widget info and save to database
1228        LauncherAppWidgetInfo launcherInfo = new LauncherAppWidgetInfo(appWidgetId);
1229        launcherInfo.spanX = spanXY[0];
1230        launcherInfo.spanY = spanXY[1];
1231
1232        LauncherModel.addItemToDatabase(this, launcherInfo,
1233                LauncherSettings.Favorites.CONTAINER_DESKTOP,
1234                screen, cellXY[0], cellXY[1], false);
1235
1236        if (!mRestoring) {
1237            mDesktopItems.add(launcherInfo);
1238
1239            // Perform actual inflation because we're live
1240            launcherInfo.hostView = mAppWidgetHost.createView(this, appWidgetId, appWidgetInfo);
1241
1242            launcherInfo.hostView.setAppWidget(appWidgetId, appWidgetInfo);
1243            launcherInfo.hostView.setTag(launcherInfo);
1244
1245            mWorkspace.addInScreen(launcherInfo.hostView, screen, cellXY[0], cellXY[1],
1246                    launcherInfo.spanX, launcherInfo.spanY, isWorkspaceLocked());
1247
1248            addWidgetToAutoAdvanceIfNeeded(launcherInfo.hostView, appWidgetInfo);
1249        }
1250    }
1251
1252    private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
1253        @Override
1254        public void onReceive(Context context, Intent intent) {
1255            final String action = intent.getAction();
1256            if (Intent.ACTION_SCREEN_OFF.equals(action)) {
1257                mUserPresent = false;
1258                updateRunning();
1259            } else if (Intent.ACTION_USER_PRESENT.equals(action)) {
1260                mUserPresent = true;
1261                updateRunning();
1262            }
1263        }
1264    };
1265
1266    @Override
1267    public void onAttachedToWindow() {
1268        super.onAttachedToWindow();
1269
1270        // Listen for broadcasts related to user-presence
1271        final IntentFilter filter = new IntentFilter();
1272        filter.addAction(Intent.ACTION_SCREEN_OFF);
1273        filter.addAction(Intent.ACTION_USER_PRESENT);
1274        registerReceiver(mReceiver, filter);
1275
1276        mAttached = true;
1277        mVisible = true;
1278    }
1279
1280    @Override
1281    public void onDetachedFromWindow() {
1282        super.onDetachedFromWindow();
1283        mVisible = false;
1284
1285        if (mAttached) {
1286            unregisterReceiver(mReceiver);
1287            mAttached = false;
1288        }
1289        updateRunning();
1290    }
1291
1292    public void onWindowVisibilityChanged(int visibility) {
1293        mVisible = visibility == View.VISIBLE;
1294        updateRunning();
1295    }
1296
1297    private void sendAdvanceMessage(long delay) {
1298        mHandler.removeMessages(ADVANCE_MSG);
1299        Message msg = mHandler.obtainMessage(ADVANCE_MSG);
1300        mHandler.sendMessageDelayed(msg, delay);
1301        mAutoAdvanceSentTime = System.currentTimeMillis();
1302    }
1303
1304    private void updateRunning() {
1305        boolean autoAdvanceRunning = mVisible && mUserPresent && !mWidgetsToAdvance.isEmpty();
1306        if (autoAdvanceRunning != mAutoAdvanceRunning) {
1307            mAutoAdvanceRunning = autoAdvanceRunning;
1308            if (autoAdvanceRunning) {
1309                long delay = mAutoAdvanceTimeLeft == -1 ? mAdvanceInterval : mAutoAdvanceTimeLeft;
1310                sendAdvanceMessage(delay);
1311            } else {
1312                if (!mWidgetsToAdvance.isEmpty()) {
1313                    mAutoAdvanceTimeLeft = Math.max(0, mAdvanceInterval -
1314                            (System.currentTimeMillis() - mAutoAdvanceSentTime));
1315                }
1316                mHandler.removeMessages(ADVANCE_MSG);
1317                mHandler.removeMessages(0); // Remove messages sent using postDelayed()
1318            }
1319        }
1320    }
1321
1322    private final Handler mHandler = new Handler() {
1323        @Override
1324        public void handleMessage(Message msg) {
1325            if (msg.what == ADVANCE_MSG) {
1326                int i = 0;
1327                for (View key: mWidgetsToAdvance.keySet()) {
1328                    final View v = key.findViewById(mWidgetsToAdvance.get(key).autoAdvanceViewId);
1329                    final int delay = mAdvanceStagger * i;
1330                    if (v instanceof Advanceable) {
1331                       postDelayed(new Runnable() {
1332                           public void run() {
1333                               ((Advanceable) v).advance();
1334                           }
1335                       }, delay);
1336                    }
1337                    i++;
1338                }
1339                sendAdvanceMessage(mAdvanceInterval);
1340            }
1341        }
1342    };
1343
1344    void addWidgetToAutoAdvanceIfNeeded(View hostView, AppWidgetProviderInfo appWidgetInfo) {
1345        if (appWidgetInfo.autoAdvanceViewId == -1) return;
1346        View v = hostView.findViewById(appWidgetInfo.autoAdvanceViewId);
1347        if (v instanceof Advanceable) {
1348            mWidgetsToAdvance.put(hostView, appWidgetInfo);
1349            ((Advanceable) v).willBeAdvancedByHost();
1350            updateRunning();
1351        }
1352    }
1353
1354    void removeWidgetToAutoAdvance(View hostView) {
1355        if (mWidgetsToAdvance.containsKey(hostView)) {
1356            mWidgetsToAdvance.remove(hostView);
1357            updateRunning();
1358        }
1359    }
1360
1361    public void removeAppWidget(LauncherAppWidgetInfo launcherInfo) {
1362        mDesktopItems.remove(launcherInfo);
1363        removeWidgetToAutoAdvance(launcherInfo.hostView);
1364        launcherInfo.hostView = null;
1365    }
1366
1367    void showOutOfSpaceMessage() {
1368        Toast.makeText(this, getString(R.string.out_of_space), Toast.LENGTH_SHORT).show();
1369    }
1370
1371    public LauncherAppWidgetHost getAppWidgetHost() {
1372        return mAppWidgetHost;
1373    }
1374
1375    public LauncherModel getModel() {
1376        return mModel;
1377    }
1378
1379    void closeSystemDialogs() {
1380        getWindow().closeAllPanels();
1381
1382        try {
1383            dismissDialog(DIALOG_CREATE_SHORTCUT);
1384            // Unlock the workspace if the dialog was showing
1385        } catch (Exception e) {
1386            // An exception is thrown if the dialog is not visible, which is fine
1387        }
1388
1389        try {
1390            dismissDialog(DIALOG_RENAME_FOLDER);
1391            // Unlock the workspace if the dialog was showing
1392        } catch (Exception e) {
1393            // An exception is thrown if the dialog is not visible, which is fine
1394        }
1395
1396        // Whatever we were doing is hereby canceled.
1397        mWaitingForResult = false;
1398    }
1399
1400    @Override
1401    protected void onNewIntent(Intent intent) {
1402        super.onNewIntent(intent);
1403
1404        // Close the menu
1405        if (Intent.ACTION_MAIN.equals(intent.getAction())) {
1406            // also will cancel mWaitingForResult.
1407            closeSystemDialogs();
1408
1409            boolean alreadyOnHome = ((intent.getFlags() & Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT)
1410                        != Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT);
1411
1412            // in all these cases, only animate if we're already on home
1413            if (LauncherApplication.isScreenXLarge()) {
1414                mWorkspace.unshrink(alreadyOnHome);
1415            }
1416            if (!mWorkspace.isDefaultPageShowing()) {
1417                // on the phone, we don't animate the change to the workspace if all apps is visible
1418                boolean animate = alreadyOnHome &&
1419                    (LauncherApplication.isScreenXLarge() || mState != State.ALL_APPS);
1420                mWorkspace.moveToDefaultScreen(animate);
1421                if (!animate) mWorkspace.updateWallpaperOffsetImmediately();
1422            }
1423            showWorkspace(alreadyOnHome);
1424
1425            final View v = getWindow().peekDecorView();
1426            if (v != null && v.getWindowToken() != null) {
1427                InputMethodManager imm = (InputMethodManager)getSystemService(
1428                        INPUT_METHOD_SERVICE);
1429                imm.hideSoftInputFromWindow(v.getWindowToken(), 0);
1430            }
1431        }
1432    }
1433
1434    @Override
1435    protected void onRestoreInstanceState(Bundle savedInstanceState) {
1436        // Do not call super here
1437        mSavedInstanceState = savedInstanceState;
1438    }
1439
1440    @Override
1441    protected void onSaveInstanceState(Bundle outState) {
1442        outState.putInt(RUNTIME_STATE_CURRENT_SCREEN, mWorkspace.getCurrentPage());
1443
1444        final ArrayList<Folder> folders = mWorkspace.getOpenFolders();
1445        if (folders.size() > 0) {
1446            final int count = folders.size();
1447            long[] ids = new long[count];
1448            for (int i = 0; i < count; i++) {
1449                final FolderInfo info = folders.get(i).getInfo();
1450                ids[i] = info.id;
1451            }
1452            outState.putLongArray(RUNTIME_STATE_USER_FOLDERS, ids);
1453        } else {
1454            super.onSaveInstanceState(outState);
1455        }
1456
1457        outState.putInt(RUNTIME_STATE, mState.ordinal());
1458
1459        if (mAddScreen > -1 && mWaitingForResult) {
1460            outState.putInt(RUNTIME_STATE_PENDING_ADD_SCREEN, mAddScreen);
1461            outState.putInt(RUNTIME_STATE_PENDING_ADD_CELL_X, mAddIntersectCellX);
1462            outState.putInt(RUNTIME_STATE_PENDING_ADD_CELL_Y, mAddIntersectCellY);
1463        }
1464
1465        if (mFolderInfo != null && mWaitingForResult) {
1466            outState.putBoolean(RUNTIME_STATE_PENDING_FOLDER_RENAME, true);
1467            outState.putLong(RUNTIME_STATE_PENDING_FOLDER_RENAME_ID, mFolderInfo.id);
1468        }
1469
1470        // Save the current AllApps drawer tab
1471        if (mAllAppsGrid != null && mAllAppsGrid instanceof AllAppsTabbed) {
1472            AllAppsTabbed tabhost = (AllAppsTabbed) mAllAppsGrid;
1473            String currentTabTag = tabhost.getCurrentTabTag();
1474            if (currentTabTag != null) {
1475                outState.putString("allapps_currentTab", currentTabTag);
1476                outState.putInt("allapps_currentPage", mAllAppsPagedView.getCurrentPage());
1477            }
1478        }
1479
1480        // Save the current customization drawer tab
1481        if (mHomeCustomizationDrawer != null) {
1482            String currentTabTag = mHomeCustomizationDrawer.getCurrentTabTag();
1483            if (currentTabTag != null) {
1484                outState.putString("customize_currentTab", currentTabTag);
1485            }
1486        }
1487    }
1488
1489    @Override
1490    public void onDestroy() {
1491        super.onDestroy();
1492
1493        try {
1494            mAppWidgetHost.stopListening();
1495        } catch (NullPointerException ex) {
1496            Log.w(TAG, "problem while stopping AppWidgetHost during Launcher destruction", ex);
1497        }
1498        mAppWidgetHost = null;
1499
1500        mWidgetsToAdvance.clear();
1501
1502        TextKeyListener.getInstance().release();
1503
1504        mModel.stopLoader();
1505
1506        unbindDesktopItems();
1507
1508        getContentResolver().unregisterContentObserver(mWidgetObserver);
1509
1510        // Some launcher layouts don't have a previous and next view
1511        if (mPreviousView != null) {
1512            dismissPreview(mPreviousView);
1513        }
1514        if (mNextView != null) {
1515            dismissPreview(mNextView);
1516        }
1517
1518        unregisterReceiver(mCloseSystemDialogsReceiver);
1519
1520        ((ViewGroup) mWorkspace.getParent()).removeAllViews();
1521        mWorkspace.removeAllViews();
1522        mWorkspace = null;
1523        mDragController = null;
1524    }
1525
1526    @Override
1527    public void startActivityForResult(Intent intent, int requestCode) {
1528        if (requestCode >= 0) mWaitingForResult = true;
1529        super.startActivityForResult(intent, requestCode);
1530    }
1531
1532    @Override
1533    public void startSearch(String initialQuery, boolean selectInitialQuery,
1534            Bundle appSearchData, boolean globalSearch) {
1535
1536        showWorkspace(true);
1537
1538        if (initialQuery == null) {
1539            // Use any text typed in the launcher as the initial query
1540            initialQuery = getTypedText();
1541            clearTypedText();
1542        }
1543        if (appSearchData == null) {
1544            appSearchData = new Bundle();
1545            appSearchData.putString(Search.SOURCE, "launcher-search");
1546        }
1547
1548        final SearchManager searchManager =
1549                (SearchManager) getSystemService(Context.SEARCH_SERVICE);
1550        searchManager.startSearch(initialQuery, selectInitialQuery, getComponentName(),
1551            appSearchData, globalSearch);
1552    }
1553
1554    @Override
1555    public boolean onCreateOptionsMenu(Menu menu) {
1556        if (isWorkspaceLocked()) {
1557            return false;
1558        }
1559
1560        super.onCreateOptionsMenu(menu);
1561
1562        menu.add(MENU_GROUP_ADD, MENU_ADD, 0, R.string.menu_add)
1563                .setIcon(android.R.drawable.ic_menu_add)
1564                .setAlphabeticShortcut('A');
1565        menu.add(0, MENU_MANAGE_APPS, 0, R.string.menu_manage_apps)
1566                .setIcon(android.R.drawable.ic_menu_manage)
1567                .setAlphabeticShortcut('M');
1568        menu.add(MENU_GROUP_WALLPAPER, MENU_WALLPAPER_SETTINGS, 0, R.string.menu_wallpaper)
1569                 .setIcon(android.R.drawable.ic_menu_gallery)
1570                 .setAlphabeticShortcut('W');
1571        menu.add(0, MENU_SEARCH, 0, R.string.menu_search)
1572                .setIcon(android.R.drawable.ic_search_category_default)
1573                .setAlphabeticShortcut(SearchManager.MENU_KEY);
1574        menu.add(0, MENU_NOTIFICATIONS, 0, R.string.menu_notifications)
1575                .setIcon(com.android.internal.R.drawable.ic_menu_notifications)
1576                .setAlphabeticShortcut('N');
1577
1578        final Intent settings = new Intent(android.provider.Settings.ACTION_SETTINGS);
1579        settings.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK |
1580                Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
1581
1582        menu.add(0, MENU_SETTINGS, 0, R.string.menu_settings)
1583                .setIcon(android.R.drawable.ic_menu_preferences).setAlphabeticShortcut('P')
1584                .setIntent(settings);
1585
1586        return true;
1587    }
1588
1589    @Override
1590    public boolean onPrepareOptionsMenu(Menu menu) {
1591        super.onPrepareOptionsMenu(menu);
1592
1593        // If all apps is animating, don't show the menu, because we don't know
1594        // which one to show.
1595        if (mAllAppsGrid.isAnimating()) {
1596            return false;
1597        }
1598
1599        // Only show the add and wallpaper options when we're not in all apps.
1600        boolean visible = !mAllAppsGrid.isVisible();
1601        menu.setGroupVisible(MENU_GROUP_ADD, visible);
1602        menu.setGroupVisible(MENU_GROUP_WALLPAPER, visible);
1603
1604        // Disable add if the workspace is full.
1605        if (visible) {
1606            CellLayout layout = (CellLayout) mWorkspace.getChildAt(mWorkspace.getCurrentPage());
1607            menu.setGroupEnabled(MENU_GROUP_ADD, layout.existsEmptyCell());
1608        }
1609
1610        return true;
1611    }
1612
1613    @Override
1614    public boolean onOptionsItemSelected(MenuItem item) {
1615        switch (item.getItemId()) {
1616            case MENU_ADD:
1617                addItems();
1618                return true;
1619            case MENU_MANAGE_APPS:
1620                manageApps();
1621                return true;
1622            case MENU_WALLPAPER_SETTINGS:
1623                startWallpaper();
1624                return true;
1625            case MENU_SEARCH:
1626                onSearchRequested();
1627                return true;
1628            case MENU_NOTIFICATIONS:
1629                showNotifications();
1630                return true;
1631        }
1632
1633        return super.onOptionsItemSelected(item);
1634    }
1635
1636    /**
1637     * Indicates that we want global search for this activity by setting the globalSearch
1638     * argument for {@link #startSearch} to true.
1639     */
1640
1641    @Override
1642    public boolean onSearchRequested() {
1643        startSearch(null, false, null, true);
1644        return true;
1645    }
1646
1647    public boolean isWorkspaceLocked() {
1648        return mWorkspaceLoading || mWaitingForResult;
1649    }
1650
1651    private void addItems() {
1652        if (LauncherApplication.isScreenXLarge()) {
1653            // Animate the widget chooser up from the bottom of the screen
1654            if (mState != State.CUSTOMIZE) {
1655                showCustomizationDrawer(true);
1656            }
1657        } else {
1658            showWorkspace(true);
1659            showAddDialog(-1, -1);
1660        }
1661    }
1662
1663    private void resetAddInfo() {
1664        mAddScreen = -1;
1665        mAddIntersectCellX = -1;
1666        mAddIntersectCellY = -1;
1667        mAddDropPosition = null;
1668    }
1669
1670    void addAppWidgetFromDrop(PendingAddWidgetInfo info, int screen, int[] position) {
1671        resetAddInfo();
1672        mAddScreen = screen;
1673        mAddDropPosition = position;
1674
1675        int appWidgetId = getAppWidgetHost().allocateAppWidgetId();
1676        AppWidgetManager.getInstance(this).bindAppWidgetId(appWidgetId, info.componentName);
1677        addAppWidgetImpl(appWidgetId, info);
1678    }
1679
1680    private void manageApps() {
1681        startActivity(new Intent(android.provider.Settings.ACTION_MANAGE_ALL_APPLICATIONS_SETTINGS));
1682    }
1683
1684    void addAppWidgetFromPick(Intent data) {
1685        // TODO: catch bad widget exception when sent
1686        int appWidgetId = data.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1);
1687        // TODO: Is this log message meaningful?
1688        if (LOGD) Log.d(TAG, "dumping extras content=" + data.getExtras());
1689        addAppWidgetImpl(appWidgetId, null);
1690    }
1691
1692    void addAppWidgetImpl(int appWidgetId, PendingAddWidgetInfo info) {
1693        AppWidgetProviderInfo appWidget = mAppWidgetManager.getAppWidgetInfo(appWidgetId);
1694
1695        if (appWidget.configure != null) {
1696            // Launch over to configure widget, if needed
1697            Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_CONFIGURE);
1698            intent.setComponent(appWidget.configure);
1699            intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId);
1700            if (info != null) {
1701                if (info.mimeType != null && !info.mimeType.isEmpty()) {
1702                    intent.putExtra(
1703                            InstallWidgetReceiver.EXTRA_APPWIDGET_CONFIGURATION_DATA_MIME_TYPE,
1704                            info.mimeType);
1705
1706                    final String mimeType = info.mimeType;
1707                    final ClipData clipData = (ClipData) info.configurationData;
1708                    final ClipDescription clipDesc = clipData.getDescription();
1709                    for (int i = 0; i < clipDesc.getMimeTypeCount(); ++i) {
1710                        if (clipDesc.getMimeType(i).equals(mimeType)) {
1711                            final ClipData.Item item = clipData.getItem(i);
1712                            final CharSequence stringData = item.getText();
1713                            final Uri uriData = item.getUri();
1714                            final Intent intentData = item.getIntent();
1715                            final String key =
1716                                InstallWidgetReceiver.EXTRA_APPWIDGET_CONFIGURATION_DATA;
1717                            if (uriData != null) {
1718                                intent.putExtra(key, uriData);
1719                            } else if (intentData != null) {
1720                                intent.putExtra(key, intentData);
1721                            } else if (stringData != null) {
1722                                intent.putExtra(key, stringData);
1723                            }
1724                            break;
1725                        }
1726                    }
1727                }
1728            }
1729
1730            startActivityForResultSafely(intent, REQUEST_CREATE_APPWIDGET);
1731        } else {
1732            // Otherwise just add it
1733            completeAddAppWidget(appWidgetId, mAddScreen);
1734        }
1735    }
1736
1737    void processShortcutFromDrop(ComponentName componentName, int screen, int[] position) {
1738        resetAddInfo();
1739        mAddScreen = screen;
1740        mAddDropPosition = position;
1741
1742        Intent createShortcutIntent = new Intent(Intent.ACTION_CREATE_SHORTCUT);
1743        createShortcutIntent.setComponent(componentName);
1744        processShortcut(createShortcutIntent);
1745    }
1746
1747    void processShortcut(Intent intent) {
1748        // Handle case where user selected "Applications"
1749        String applicationName = getResources().getString(R.string.group_applications);
1750        String shortcutName = intent.getStringExtra(Intent.EXTRA_SHORTCUT_NAME);
1751
1752        if (applicationName != null && applicationName.equals(shortcutName)) {
1753            Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
1754            mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);
1755
1756            Intent pickIntent = new Intent(Intent.ACTION_PICK_ACTIVITY);
1757            pickIntent.putExtra(Intent.EXTRA_INTENT, mainIntent);
1758            pickIntent.putExtra(Intent.EXTRA_TITLE, getText(R.string.title_select_application));
1759            startActivityForResultSafely(pickIntent, REQUEST_PICK_APPLICATION);
1760        } else {
1761            startActivityForResultSafely(intent, REQUEST_CREATE_SHORTCUT);
1762        }
1763    }
1764
1765    void processWallpaper(Intent intent) {
1766        startActivityForResult(intent, REQUEST_PICK_WALLPAPER);
1767    }
1768
1769    void addLiveFolderFromDrop(ComponentName componentName, int screen, int[] position) {
1770        resetAddInfo();
1771        mAddScreen = screen;
1772        mAddDropPosition = position;
1773
1774        Intent createFolderIntent = new Intent(LiveFolders.ACTION_CREATE_LIVE_FOLDER);
1775        createFolderIntent.setComponent(componentName);
1776
1777        addLiveFolder(createFolderIntent);
1778    }
1779
1780    void addLiveFolder(Intent intent) { // YYY add screen intersect etc. parameters here
1781        // Handle case where user selected "Folder"
1782        String folderName = getResources().getString(R.string.group_folder);
1783        String shortcutName = intent.getStringExtra(Intent.EXTRA_SHORTCUT_NAME);
1784
1785        if (folderName != null && folderName.equals(shortcutName)) {
1786            addFolder(mAddScreen, mAddIntersectCellX, mAddIntersectCellY);
1787        } else {
1788            startActivityForResultSafely(intent, REQUEST_CREATE_LIVE_FOLDER);
1789        }
1790    }
1791
1792    void addFolder(int screen, int intersectCellX, int intersectCellY) {
1793        UserFolderInfo folderInfo = new UserFolderInfo();
1794        folderInfo.title = getText(R.string.folder_name);
1795
1796        final CellLayout layout = (CellLayout) mWorkspace.getChildAt(screen);
1797        final int[] cellXY = mTmpAddItemCellCoordinates;
1798        if (!layout.findCellForSpanThatIntersects(cellXY, 1, 1, intersectCellX, intersectCellY)) {
1799            showOutOfSpaceMessage();
1800            return;
1801        }
1802
1803        // Update the model
1804        LauncherModel.addItemToDatabase(this, folderInfo,
1805                LauncherSettings.Favorites.CONTAINER_DESKTOP,
1806                screen, cellXY[0], cellXY[1], false);
1807        sFolders.put(folderInfo.id, folderInfo);
1808
1809        // Create the view
1810        FolderIcon newFolder = FolderIcon.fromXml(R.layout.folder_icon, this,
1811                (ViewGroup) mWorkspace.getChildAt(mWorkspace.getCurrentPage()),
1812                folderInfo, mIconCache);
1813        mWorkspace.addInScreen(newFolder, screen, cellXY[0], cellXY[1], 1, 1, isWorkspaceLocked());
1814    }
1815
1816    void removeFolder(FolderInfo folder) {
1817        sFolders.remove(folder.id);
1818    }
1819
1820    private void completeAddLiveFolder(
1821            Intent data, int screen, int intersectCellX, int intersectCellY) {
1822        final CellLayout layout = (CellLayout) mWorkspace.getChildAt(screen);
1823        final int[] cellXY = mTmpAddItemCellCoordinates;
1824        if (!layout.findCellForSpanThatIntersects(cellXY, 1, 1, intersectCellX, intersectCellY)) {
1825            showOutOfSpaceMessage();
1826            return;
1827        }
1828
1829        final LiveFolderInfo info = addLiveFolder(this, data, screen, cellXY[0], cellXY[1], false);
1830
1831        if (!mRestoring) {
1832            final View view = LiveFolderIcon.fromXml(R.layout.live_folder_icon, this,
1833                (ViewGroup) mWorkspace.getChildAt(mWorkspace.getCurrentPage()), info);
1834            mWorkspace.addInScreen(view, screen, cellXY[0], cellXY[1], 1, 1, isWorkspaceLocked());
1835        }
1836    }
1837
1838    static LiveFolderInfo addLiveFolder(Context context, Intent data,
1839            int screen, int cellX, int cellY, boolean notify) {
1840
1841        Intent baseIntent = data.getParcelableExtra(LiveFolders.EXTRA_LIVE_FOLDER_BASE_INTENT);
1842        String name = data.getStringExtra(LiveFolders.EXTRA_LIVE_FOLDER_NAME);
1843
1844        Drawable icon = null;
1845        Intent.ShortcutIconResource iconResource = null;
1846
1847        Parcelable extra = data.getParcelableExtra(LiveFolders.EXTRA_LIVE_FOLDER_ICON);
1848        if (extra != null && extra instanceof Intent.ShortcutIconResource) {
1849            try {
1850                iconResource = (Intent.ShortcutIconResource) extra;
1851                final PackageManager packageManager = context.getPackageManager();
1852                Resources resources = packageManager.getResourcesForApplication(
1853                        iconResource.packageName);
1854                final int id = resources.getIdentifier(iconResource.resourceName, null, null);
1855                icon = resources.getDrawable(id);
1856            } catch (Exception e) {
1857                Log.w(TAG, "Could not load live folder icon: " + extra);
1858            }
1859        }
1860
1861        if (icon == null) {
1862            icon = context.getResources().getDrawable(R.drawable.ic_launcher_folder);
1863        }
1864
1865        final LiveFolderInfo info = new LiveFolderInfo();
1866        info.icon = Utilities.createIconBitmap(icon, context);
1867        info.title = name;
1868        info.iconResource = iconResource;
1869        info.uri = data.getData();
1870        info.baseIntent = baseIntent;
1871        info.displayMode = data.getIntExtra(LiveFolders.EXTRA_LIVE_FOLDER_DISPLAY_MODE,
1872                LiveFolders.DISPLAY_MODE_GRID);
1873
1874        LauncherModel.addItemToDatabase(context, info, LauncherSettings.Favorites.CONTAINER_DESKTOP,
1875                screen, cellX, cellY, notify);
1876        sFolders.put(info.id, info);
1877
1878        return info;
1879    }
1880
1881    private void showNotifications() {
1882        final StatusBarManager statusBar = (StatusBarManager) getSystemService(STATUS_BAR_SERVICE);
1883        if (statusBar != null) {
1884            statusBar.expand();
1885        }
1886    }
1887
1888    private void startWallpaper() {
1889        showWorkspace(true);
1890        final Intent pickWallpaper = new Intent(Intent.ACTION_SET_WALLPAPER);
1891        Intent chooser = Intent.createChooser(pickWallpaper,
1892                getText(R.string.chooser_wallpaper));
1893        // NOTE: Adds a configure option to the chooser if the wallpaper supports it
1894        //       Removed in Eclair MR1
1895//        WallpaperManager wm = (WallpaperManager)
1896//                getSystemService(Context.WALLPAPER_SERVICE);
1897//        WallpaperInfo wi = wm.getWallpaperInfo();
1898//        if (wi != null && wi.getSettingsActivity() != null) {
1899//            LabeledIntent li = new LabeledIntent(getPackageName(),
1900//                    R.string.configure_wallpaper, 0);
1901//            li.setClassName(wi.getPackageName(), wi.getSettingsActivity());
1902//            chooser.putExtra(Intent.EXTRA_INITIAL_INTENTS, new Intent[] { li });
1903//        }
1904        startActivityForResult(chooser, REQUEST_PICK_WALLPAPER);
1905    }
1906
1907    /**
1908     * Registers various content observers. The current implementation registers
1909     * only a favorites observer to keep track of the favorites applications.
1910     */
1911    private void registerContentObservers() {
1912        ContentResolver resolver = getContentResolver();
1913        resolver.registerContentObserver(LauncherProvider.CONTENT_APPWIDGET_RESET_URI,
1914                true, mWidgetObserver);
1915    }
1916
1917    @Override
1918    public boolean dispatchKeyEvent(KeyEvent event) {
1919        if (event.getAction() == KeyEvent.ACTION_DOWN) {
1920            switch (event.getKeyCode()) {
1921                case KeyEvent.KEYCODE_HOME:
1922                    return true;
1923                case KeyEvent.KEYCODE_VOLUME_DOWN:
1924                    if (SystemProperties.getInt("debug.launcher2.dumpstate", 0) != 0) {
1925                        dumpState();
1926                        return true;
1927                    }
1928                    break;
1929            }
1930        } else if (event.getAction() == KeyEvent.ACTION_UP) {
1931            switch (event.getKeyCode()) {
1932                case KeyEvent.KEYCODE_HOME:
1933                    return true;
1934            }
1935        }
1936
1937        return super.dispatchKeyEvent(event);
1938    }
1939
1940    @Override
1941    public void onBackPressed() {
1942        if (mState == State.ALL_APPS || mState == State.CUSTOMIZE) {
1943            showWorkspace(true);
1944        } else {
1945            closeFolder();
1946        }
1947        // Some launcher layouts don't have a previous and next view
1948        if (mPreviousView != null) {
1949            dismissPreview(mPreviousView);
1950            dismissPreview(mNextView);
1951        }
1952    }
1953
1954    private void closeFolder() {
1955        Folder folder = mWorkspace.getOpenFolder();
1956        if (folder != null) {
1957            closeFolder(folder);
1958        }
1959    }
1960
1961    void closeFolder(Folder folder) {
1962        folder.getInfo().opened = false;
1963        ViewGroup parent = (ViewGroup) folder.getParent();
1964        if (parent != null) {
1965            CellLayout cl = (CellLayout) parent;
1966            cl.removeViewWithoutMarkingCells(folder);
1967            if (folder instanceof DropTarget) {
1968                // Live folders aren't DropTargets.
1969                mDragController.removeDropTarget((DropTarget)folder);
1970            }
1971        }
1972        folder.onClose();
1973    }
1974
1975    /**
1976     * Re-listen when widgets are reset.
1977     */
1978    private void onAppWidgetReset() {
1979        mAppWidgetHost.startListening();
1980    }
1981
1982    /**
1983     * Go through the and disconnect any of the callbacks in the drawables and the views or we
1984     * leak the previous Home screen on orientation change.
1985     */
1986    private void unbindDesktopItems() {
1987        for (ItemInfo item: mDesktopItems) {
1988            item.unbind();
1989        }
1990        mDesktopItems.clear();
1991    }
1992
1993    /**
1994     * Launches the intent referred by the clicked shortcut.
1995     *
1996     * @param v The view representing the clicked shortcut.
1997     */
1998    public void onClick(View v) {
1999        Object tag = v.getTag();
2000        if (tag instanceof ShortcutInfo) {
2001            // Open shortcut
2002            final Intent intent = ((ShortcutInfo) tag).intent;
2003            int[] pos = new int[2];
2004            v.getLocationOnScreen(pos);
2005            intent.setSourceBounds(new Rect(pos[0], pos[1],
2006                    pos[0] + v.getWidth(), pos[1] + v.getHeight()));
2007            startActivitySafely(intent, tag);
2008        } else if (tag instanceof FolderInfo) {
2009            handleFolderClick((FolderInfo) tag);
2010        } else if (v == mHandleView) {
2011            if (mState == State.ALL_APPS) {
2012                showWorkspace(true);
2013            } else {
2014                showAllApps(true);
2015            }
2016        }
2017    }
2018
2019    public boolean onTouch(View v, MotionEvent event) {
2020        // this is an intercepted event being forwarded from mWorkspace;
2021        // clicking anywhere on the workspace causes the customization drawer to slide down
2022        showWorkspace(true);
2023        return false;
2024    }
2025
2026    /**
2027     * Event handler for the search button
2028     *
2029     * @param v The view that was clicked.
2030     */
2031    public void onClickSearchButton(View v) {
2032        startSearch(null, false, null, true);
2033        // Use a custom animation for launching search
2034        overridePendingTransition(R.anim.fade_in_fast, R.anim.fade_out_fast);
2035    }
2036
2037    /**
2038     * Event handler for the voice button
2039     *
2040     * @param v The view that was clicked.
2041     */
2042    public void onClickVoiceButton(View v) {
2043        startVoiceSearch();
2044    }
2045
2046    private void startVoiceSearch() {
2047        Intent intent = new Intent(RecognizerIntent.ACTION_WEB_SEARCH);
2048        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
2049        startActivity(intent);
2050    }
2051
2052    /**
2053     * Event handler for the "gear" button that appears on the home screen, which
2054     * enters home screen customization mode.
2055     *
2056     * @param v The view that was clicked.
2057     */
2058    public void onClickConfigureButton(View v) {
2059        addItems();
2060    }
2061
2062    /**
2063     * Event handler for the "grid" button that appears on the home screen, which
2064     * enters all apps mode.
2065     *
2066     * @param v The view that was clicked.
2067     */
2068    public void onClickAllAppsButton(View v) {
2069        showAllApps(true);
2070    }
2071
2072    public void onClickAppMarketButton(View v) {
2073        if (mAppMarketIntent != null) {
2074            startActivitySafely(mAppMarketIntent, "app market");
2075        }
2076    }
2077
2078    void startApplicationDetailsActivity(ComponentName componentName) {
2079        String packageName = componentName.getPackageName();
2080        Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
2081                Uri.fromParts("package", packageName, null));
2082        startActivity(intent);
2083    }
2084
2085    void startApplicationUninstallActivity(ApplicationInfo appInfo) {
2086        if ((appInfo.flags & ApplicationInfo.DOWNLOADED_FLAG) == 0) {
2087            // System applications cannot be installed. For now, show a toast explaining that.
2088            // We may give them the option of disabling apps this way.
2089            int messageId = R.string.uninstall_system_app_text;
2090            Toast.makeText(this, messageId, Toast.LENGTH_SHORT).show();
2091        } else {
2092            String packageName = appInfo.componentName.getPackageName();
2093            String className = appInfo.componentName.getClassName();
2094            Intent intent = new Intent(
2095                    Intent.ACTION_DELETE, Uri.fromParts("package", packageName, className));
2096            startActivity(intent);
2097        }
2098    }
2099
2100    void startActivitySafely(Intent intent, Object tag) {
2101        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
2102        try {
2103            startActivity(intent);
2104        } catch (ActivityNotFoundException e) {
2105            Toast.makeText(this, R.string.activity_not_found, Toast.LENGTH_SHORT).show();
2106            Log.e(TAG, "Unable to launch. tag=" + tag + " intent=" + intent, e);
2107        } catch (SecurityException e) {
2108            Toast.makeText(this, R.string.activity_not_found, Toast.LENGTH_SHORT).show();
2109            Log.e(TAG, "Launcher does not have the permission to launch " + intent +
2110                    ". Make sure to create a MAIN intent-filter for the corresponding activity " +
2111                    "or use the exported attribute for this activity. "
2112                    + "tag="+ tag + " intent=" + intent, e);
2113        }
2114    }
2115
2116    void startActivityForResultSafely(Intent intent, int requestCode) {
2117        try {
2118            startActivityForResult(intent, requestCode);
2119        } catch (ActivityNotFoundException e) {
2120            Toast.makeText(this, R.string.activity_not_found, Toast.LENGTH_SHORT).show();
2121        } catch (SecurityException e) {
2122            Toast.makeText(this, R.string.activity_not_found, Toast.LENGTH_SHORT).show();
2123            Log.e(TAG, "Launcher does not have the permission to launch " + intent +
2124                    ". Make sure to create a MAIN intent-filter for the corresponding activity " +
2125                    "or use the exported attribute for this activity.", e);
2126        }
2127    }
2128
2129    private void handleFolderClick(FolderInfo folderInfo) {
2130        if (!folderInfo.opened) {
2131            // Close any open folder
2132            closeFolder();
2133            // Open the requested folder
2134            openFolder(folderInfo);
2135        } else {
2136            // Find the open folder...
2137            Folder openFolder = mWorkspace.getFolderForTag(folderInfo);
2138            int folderScreen;
2139            if (openFolder != null) {
2140                folderScreen = mWorkspace.getPageForView(openFolder);
2141                // .. and close it
2142                closeFolder(openFolder);
2143                if (folderScreen != mWorkspace.getCurrentPage()) {
2144                    // Close any folder open on the current screen
2145                    closeFolder();
2146                    // Pull the folder onto this screen
2147                    openFolder(folderInfo);
2148                }
2149            }
2150        }
2151    }
2152
2153    /**
2154     * Opens the user folder described by the specified tag. The opening of the folder
2155     * is animated relative to the specified View. If the View is null, no animation
2156     * is played.
2157     *
2158     * @param folderInfo The FolderInfo describing the folder to open.
2159     */
2160    public void openFolder(FolderInfo folderInfo) {
2161        Folder openFolder;
2162
2163        if (folderInfo instanceof UserFolderInfo) {
2164            openFolder = UserFolder.fromXml(this);
2165        } else if (folderInfo instanceof LiveFolderInfo) {
2166            openFolder = com.android.launcher2.LiveFolder.fromXml(this, folderInfo);
2167        } else {
2168            return;
2169        }
2170
2171        openFolder.setDragController(mDragController);
2172        openFolder.setLauncher(this);
2173
2174        openFolder.bind(folderInfo);
2175        folderInfo.opened = true;
2176
2177        mWorkspace.addInFullScreen(openFolder, folderInfo.screen);
2178
2179        openFolder.onOpen();
2180    }
2181
2182    public boolean onLongClick(View v) {
2183        switch (v.getId()) {
2184            case R.id.previous_screen:
2185                if (mState != State.ALL_APPS) {
2186                    mWorkspace.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS,
2187                            HapticFeedbackConstants.FLAG_IGNORE_VIEW_SETTING);
2188                    showPreviews(v);
2189                }
2190                return true;
2191            case R.id.next_screen:
2192                if (mState != State.ALL_APPS) {
2193                    mWorkspace.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS,
2194                            HapticFeedbackConstants.FLAG_IGNORE_VIEW_SETTING);
2195                    showPreviews(v);
2196                }
2197                return true;
2198            case R.id.all_apps_button:
2199                if (mState != State.ALL_APPS) {
2200                    mWorkspace.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS,
2201                            HapticFeedbackConstants.FLAG_IGNORE_VIEW_SETTING);
2202                    showPreviews(v);
2203                }
2204                return true;
2205        }
2206
2207        if (isWorkspaceLocked()) {
2208            return false;
2209        }
2210
2211        if (!(v instanceof CellLayout)) {
2212            v = (View) v.getParent();
2213        }
2214
2215
2216        resetAddInfo();
2217        CellLayout.CellInfo longClickCellInfo = (CellLayout.CellInfo) v.getTag();
2218        // This happens when long clicking an item with the dpad/trackball
2219        if (longClickCellInfo == null || !longClickCellInfo.valid) {
2220            return true;
2221        }
2222
2223        final View itemUnderLongClick = longClickCellInfo.cell;
2224
2225        if (mWorkspace.allowLongPress() && !mDragController.isDragging()) {
2226            if (itemUnderLongClick == null) {
2227                // User long pressed on empty space
2228                mWorkspace.setAllowLongPress(false);
2229                mWorkspace.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS,
2230                        HapticFeedbackConstants.FLAG_IGNORE_VIEW_SETTING);
2231                if (!LauncherApplication.isScreenXLarge()) {
2232                    showAddDialog(longClickCellInfo.cellX, longClickCellInfo.cellY);
2233                }
2234            } else {
2235                if (!(itemUnderLongClick instanceof Folder)) {
2236                    // User long pressed on an item
2237                    mWorkspace.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS,
2238                            HapticFeedbackConstants.FLAG_IGNORE_VIEW_SETTING);
2239                    mAddIntersectCellX = longClickCellInfo.cellX;
2240                    mAddIntersectCellY = longClickCellInfo.cellY;
2241                    mWorkspace.startDrag(longClickCellInfo);
2242                }
2243            }
2244        }
2245        return true;
2246    }
2247
2248    @SuppressWarnings({"unchecked"})
2249    private void dismissPreview(final View v) {
2250        final PopupWindow window = (PopupWindow) v.getTag();
2251        if (window != null) {
2252            window.setOnDismissListener(new PopupWindow.OnDismissListener() {
2253                public void onDismiss() {
2254                    ViewGroup group = (ViewGroup) v.getTag(R.id.workspace);
2255                    int count = group.getChildCount();
2256                    for (int i = 0; i < count; i++) {
2257                        ((ImageView) group.getChildAt(i)).setImageDrawable(null);
2258                    }
2259                    ArrayList<Bitmap> bitmaps = (ArrayList<Bitmap>) v.getTag(R.id.icon);
2260                    for (Bitmap bitmap : bitmaps) bitmap.recycle();
2261
2262                    v.setTag(R.id.workspace, null);
2263                    v.setTag(R.id.icon, null);
2264                    window.setOnDismissListener(null);
2265                }
2266            });
2267            window.dismiss();
2268        }
2269        v.setTag(null);
2270    }
2271
2272    private void showPreviews(View anchor) {
2273        showPreviews(anchor, 0, mWorkspace.getChildCount());
2274    }
2275
2276    private void showPreviews(final View anchor, int start, int end) {
2277        final Resources resources = getResources();
2278        final Workspace workspace = mWorkspace;
2279
2280        CellLayout cell = ((CellLayout) workspace.getChildAt(start));
2281
2282        float max = workspace.getChildCount();
2283
2284        final Rect r = new Rect();
2285        resources.getDrawable(R.drawable.preview_background).getPadding(r);
2286        int extraW = (int) ((r.left + r.right) * max);
2287        int extraH = r.top + r.bottom;
2288
2289        int aW = cell.getWidth() - extraW;
2290        float w = aW / max;
2291
2292        int width = cell.getWidth();
2293        int height = cell.getHeight();
2294        int x = cell.getLeftPadding();
2295        int y = cell.getTopPadding();
2296        width -= (x + cell.getRightPadding());
2297        height -= (y + cell.getBottomPadding());
2298
2299        float scale = w / width;
2300
2301        int count = end - start;
2302
2303        final float sWidth = width * scale;
2304        float sHeight = height * scale;
2305
2306        LinearLayout preview = new LinearLayout(this);
2307
2308        PreviewTouchHandler handler = new PreviewTouchHandler(anchor);
2309        ArrayList<Bitmap> bitmaps = new ArrayList<Bitmap>(count);
2310
2311        for (int i = start; i < end; i++) {
2312            ImageView image = new ImageView(this);
2313            cell = (CellLayout) workspace.getChildAt(i);
2314
2315            final Bitmap bitmap = Bitmap.createBitmap((int) sWidth, (int) sHeight,
2316                    Bitmap.Config.ARGB_8888);
2317
2318            final Canvas c = new Canvas(bitmap);
2319            c.scale(scale, scale);
2320            c.translate(-cell.getLeftPadding(), -cell.getTopPadding());
2321            cell.drawChildren(c);
2322
2323            image.setBackgroundDrawable(resources.getDrawable(R.drawable.preview_background));
2324            image.setImageBitmap(bitmap);
2325            image.setTag(i);
2326            image.setOnClickListener(handler);
2327            image.setOnFocusChangeListener(handler);
2328            image.setFocusable(true);
2329            if (i == mWorkspace.getCurrentPage()) image.requestFocus();
2330
2331            preview.addView(image,
2332                    LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.WRAP_CONTENT);
2333
2334            bitmaps.add(bitmap);
2335        }
2336
2337        final PopupWindow p = new PopupWindow(this);
2338        p.setContentView(preview);
2339        p.setWidth((int) (sWidth * count + extraW));
2340        p.setHeight((int) (sHeight + extraH));
2341        p.setAnimationStyle(R.style.AnimationPreview);
2342        p.setOutsideTouchable(true);
2343        p.setFocusable(true);
2344        p.setBackgroundDrawable(new ColorDrawable(0));
2345        p.showAsDropDown(anchor, 0, 0);
2346
2347        p.setOnDismissListener(new PopupWindow.OnDismissListener() {
2348            public void onDismiss() {
2349                dismissPreview(anchor);
2350            }
2351        });
2352
2353        anchor.setTag(p);
2354        anchor.setTag(R.id.workspace, preview);
2355        anchor.setTag(R.id.icon, bitmaps);
2356    }
2357
2358    class PreviewTouchHandler implements View.OnClickListener, Runnable, View.OnFocusChangeListener {
2359        private final View mAnchor;
2360
2361        public PreviewTouchHandler(View anchor) {
2362            mAnchor = anchor;
2363        }
2364
2365        public void onClick(View v) {
2366            mWorkspace.snapToPage((Integer) v.getTag());
2367            v.post(this);
2368        }
2369
2370        public void run() {
2371            dismissPreview(mAnchor);
2372        }
2373
2374        public void onFocusChange(View v, boolean hasFocus) {
2375            if (hasFocus) {
2376                mWorkspace.snapToPage((Integer) v.getTag());
2377            }
2378        }
2379    }
2380
2381    Workspace getWorkspace() {
2382        return mWorkspace;
2383    }
2384
2385    @Override
2386    protected Dialog onCreateDialog(int id) {
2387        switch (id) {
2388            case DIALOG_CREATE_SHORTCUT:
2389                return new CreateShortcut().createDialog();
2390            case DIALOG_RENAME_FOLDER:
2391                return new RenameFolder().createDialog();
2392        }
2393
2394        return super.onCreateDialog(id);
2395    }
2396
2397    @Override
2398    protected void onPrepareDialog(int id, Dialog dialog) {
2399        switch (id) {
2400            case DIALOG_CREATE_SHORTCUT:
2401                break;
2402            case DIALOG_RENAME_FOLDER:
2403                if (mFolderInfo != null) {
2404                    EditText input = (EditText) dialog.findViewById(R.id.folder_name);
2405                    final CharSequence text = mFolderInfo.title;
2406                    input.setText(text);
2407                    input.setSelection(0, text.length());
2408                }
2409                break;
2410        }
2411    }
2412
2413    void showRenameDialog(FolderInfo info) {
2414        mFolderInfo = info;
2415        mWaitingForResult = true;
2416        showDialog(DIALOG_RENAME_FOLDER);
2417    }
2418
2419    private void showAddDialog(int intersectX, int intersectY) {
2420        resetAddInfo();
2421        mAddIntersectCellX = intersectX;
2422        mAddIntersectCellY = intersectY;
2423        mAddScreen = mWorkspace.getCurrentPage();
2424        mWaitingForResult = true;
2425        showDialog(DIALOG_CREATE_SHORTCUT);
2426    }
2427
2428    private void pickShortcut() {
2429        // Insert extra item to handle picking application
2430        Bundle bundle = new Bundle();
2431
2432        ArrayList<String> shortcutNames = new ArrayList<String>();
2433        shortcutNames.add(getString(R.string.group_applications));
2434        bundle.putStringArrayList(Intent.EXTRA_SHORTCUT_NAME, shortcutNames);
2435
2436        ArrayList<ShortcutIconResource> shortcutIcons = new ArrayList<ShortcutIconResource>();
2437        shortcutIcons.add(ShortcutIconResource.fromContext(Launcher.this,
2438                        R.drawable.ic_launcher_application));
2439        bundle.putParcelableArrayList(Intent.EXTRA_SHORTCUT_ICON_RESOURCE, shortcutIcons);
2440
2441        Intent pickIntent = new Intent(Intent.ACTION_PICK_ACTIVITY);
2442        pickIntent.putExtra(Intent.EXTRA_INTENT, new Intent(Intent.ACTION_CREATE_SHORTCUT));
2443        pickIntent.putExtra(Intent.EXTRA_TITLE, getText(R.string.title_select_shortcut));
2444        pickIntent.putExtras(bundle);
2445
2446        startActivityForResult(pickIntent, REQUEST_PICK_SHORTCUT);
2447    }
2448
2449    private class RenameFolder {
2450        private EditText mInput;
2451
2452        Dialog createDialog() {
2453            final View layout = View.inflate(Launcher.this, R.layout.rename_folder, null);
2454            mInput = (EditText) layout.findViewById(R.id.folder_name);
2455
2456            AlertDialog.Builder builder = new AlertDialog.Builder(Launcher.this);
2457            builder.setIcon(0);
2458            builder.setTitle(getString(R.string.rename_folder_title));
2459            builder.setCancelable(true);
2460            builder.setOnCancelListener(new Dialog.OnCancelListener() {
2461                public void onCancel(DialogInterface dialog) {
2462                    cleanup();
2463                }
2464            });
2465            builder.setNegativeButton(getString(R.string.cancel_action),
2466                new Dialog.OnClickListener() {
2467                    public void onClick(DialogInterface dialog, int which) {
2468                        cleanup();
2469                    }
2470                }
2471            );
2472            builder.setPositiveButton(getString(R.string.rename_action),
2473                new Dialog.OnClickListener() {
2474                    public void onClick(DialogInterface dialog, int which) {
2475                        changeFolderName();
2476                    }
2477                }
2478            );
2479            builder.setView(layout);
2480
2481            final AlertDialog dialog = builder.create();
2482            dialog.setOnShowListener(new DialogInterface.OnShowListener() {
2483                public void onShow(DialogInterface dialog) {
2484                    mWaitingForResult = true;
2485                    mInput.requestFocus();
2486                    InputMethodManager inputManager = (InputMethodManager)
2487                            getSystemService(Context.INPUT_METHOD_SERVICE);
2488                    inputManager.showSoftInput(mInput, 0);
2489                }
2490            });
2491
2492            return dialog;
2493        }
2494
2495        private void changeFolderName() {
2496            final String name = mInput.getText().toString();
2497            if (!TextUtils.isEmpty(name)) {
2498                // Make sure we have the right folder info
2499                mFolderInfo = sFolders.get(mFolderInfo.id);
2500                mFolderInfo.title = name;
2501                LauncherModel.updateItemInDatabase(Launcher.this, mFolderInfo);
2502
2503                if (mWorkspaceLoading) {
2504                    lockAllApps();
2505                    mModel.startLoader(Launcher.this, false);
2506                } else {
2507                    final FolderIcon folderIcon = (FolderIcon)
2508                            mWorkspace.getViewForTag(mFolderInfo);
2509                    if (folderIcon != null) {
2510                        folderIcon.setText(name);
2511                        getWorkspace().requestLayout();
2512                    } else {
2513                        lockAllApps();
2514                        mWorkspaceLoading = true;
2515                        mModel.startLoader(Launcher.this, false);
2516                    }
2517                }
2518            }
2519            cleanup();
2520        }
2521
2522        private void cleanup() {
2523            dismissDialog(DIALOG_RENAME_FOLDER);
2524            mWaitingForResult = false;
2525            mFolderInfo = null;
2526        }
2527    }
2528
2529    // Now a part of LauncherModel.Callbacks. Used to reorder loading steps.
2530    public boolean isAllAppsVisible() {
2531        return mState == State.ALL_APPS;
2532    }
2533
2534    // AllAppsView.Watcher
2535    public void zoomed(float zoom) {
2536        // In XLarge view, we zoom down the workspace below all apps so it's still visible
2537        if (zoom == 1.0f && !LauncherApplication.isScreenXLarge()) {
2538            mWorkspace.setVisibility(View.GONE);
2539        }
2540    }
2541
2542    private void showToolbarButton(View button) {
2543        button.setAlpha(1.0f);
2544        button.setVisibility(View.VISIBLE);
2545        button.setFocusable(true);
2546        button.setClickable(true);
2547    }
2548
2549    private void hideToolbarButton(View button) {
2550        button.setAlpha(0.0f);
2551        // We can't set it to GONE, otherwise the RelativeLayout gets screwed up
2552        button.setVisibility(View.INVISIBLE);
2553        button.setFocusable(false);
2554        button.setClickable(false);
2555    }
2556
2557    /**
2558     * Helper function for showing or hiding a toolbar button, possibly animated.
2559     *
2560     * @param show If true, create an animation to the show the item. Otherwise, hide it.
2561     * @param view The toolbar button to be animated
2562     * @param seq A AnimatorSet that will be used to animate the transition. If null, the
2563     * transition will not be animated.
2564     */
2565    private void hideOrShowToolbarButton(boolean show, final View view, AnimatorSet seq) {
2566        final boolean showing = show;
2567        final boolean hiding = !show;
2568
2569        final int duration = show ?
2570                getResources().getInteger(R.integer.config_toolbarButtonFadeInTime) :
2571                getResources().getInteger(R.integer.config_toolbarButtonFadeOutTime);
2572
2573        if (seq != null) {
2574            Animator anim = ObjectAnimator.ofFloat(view, "alpha", show ? 1.0f : 0.0f);
2575            anim.setDuration(duration);
2576            anim.addListener(new AnimatorListenerAdapter() {
2577                @Override
2578                public void onAnimationStart(Animator animation) {
2579                    if (showing) showToolbarButton(view);
2580                }
2581                @Override
2582                public void onAnimationEnd(Animator animation) {
2583                    if (hiding) hideToolbarButton(view);
2584                }
2585            });
2586            seq.play(anim);
2587        } else {
2588            if (showing) {
2589                showToolbarButton(view);
2590            } else {
2591                hideToolbarButton(view);
2592            }
2593        }
2594    }
2595
2596    /**
2597     * Show/hide the appropriate toolbar buttons for newState.
2598     * If showSeq or hideSeq is null, the transition will be done immediately (not animated).
2599     *
2600     * @param newState The state that is being switched to
2601     * @param showSeq AnimatorSet in which to put "show" animations, or null.
2602     * @param hideSeq AnimatorSet in which to put "hide" animations, or null.
2603     */
2604    private void hideAndShowToolbarButtons(State newState, AnimatorSet showSeq, AnimatorSet hideSeq) {
2605        final View searchButton = findViewById(R.id.search_button_cluster);
2606        final View allAppsButton = findViewById(R.id.all_apps_button);
2607        final View divider = findViewById(R.id.divider);
2608        final View configureButton = findViewById(R.id.configure_button);
2609
2610        switch (newState) {
2611        case WORKSPACE:
2612            hideOrShowToolbarButton(true, searchButton, showSeq);
2613            hideOrShowToolbarButton(true, allAppsButton, showSeq);
2614            hideOrShowToolbarButton(true, divider, showSeq);
2615            hideOrShowToolbarButton(true, configureButton, showSeq);
2616            mDeleteZone.setOverlappingViews(new View[] { allAppsButton, divider, configureButton });
2617            mDeleteZone.setDragAndDropEnabled(true);
2618            mDeleteZone.setText(getResources().getString(R.string.delete_zone_label_workspace));
2619            break;
2620        case ALL_APPS:
2621            hideOrShowToolbarButton(false, configureButton, hideSeq);
2622            hideOrShowToolbarButton(false, searchButton, hideSeq);
2623            hideOrShowToolbarButton(false, divider, hideSeq);
2624            hideOrShowToolbarButton(false, allAppsButton, hideSeq);
2625            mDeleteZone.setDragAndDropEnabled(false);
2626            mDeleteZone.setText(getResources().getString(R.string.delete_zone_label_all_apps));
2627            break;
2628        case CUSTOMIZE:
2629            hideOrShowToolbarButton(false, allAppsButton, hideSeq);
2630            hideOrShowToolbarButton(false, searchButton, hideSeq);
2631            hideOrShowToolbarButton(false, divider, hideSeq);
2632            hideOrShowToolbarButton(false, configureButton, hideSeq);
2633            mDeleteZone.setDragAndDropEnabled(false);
2634            break;
2635        }
2636    }
2637
2638    /**
2639     * Helper method for the cameraZoomIn/cameraZoomOut animations
2640     * @param view The view being animated
2641     * @param state The state that we are moving in or out of -- either ALL_APPS or CUSTOMIZE
2642     * @param scaleFactor The scale factor used for the zoom
2643     */
2644    private void setPivotsForZoom(View view, State state, float scaleFactor) {
2645        final int height = view.getHeight();
2646
2647        view.setPivotX(view.getWidth() / 2.0f);
2648        // Set pivotY so that at the starting zoom factor, the view is partially
2649        // visible. Modifying initialHeightFactor changes how much of the view is
2650        // initially showing, and hence the perceived angle from which the view enters.
2651        if (state == State.ALL_APPS) {
2652            final float initialHeightFactor = 0.165f;
2653            view.setPivotY((1 - initialHeightFactor) * height);
2654        } else {
2655            final float initialHeightFactor = 0.2f;
2656            view.setPivotY(-initialHeightFactor * height);
2657        }
2658    }
2659
2660    /**
2661     * Zoom the camera out from the workspace to reveal 'toView'.
2662     * Assumes that the view to show is anchored at either the very top or very bottom
2663     * of the screen.
2664     * @param toState The state to zoom out to. Must be ALL_APPS or CUSTOMIZE.
2665     */
2666    private void cameraZoomOut(State toState, boolean animated) {
2667        final Resources res = getResources();
2668        final boolean toAllApps = (toState == State.ALL_APPS);
2669
2670        final int duration = toAllApps ?
2671                res.getInteger(R.integer.config_allAppsZoomInTime) :
2672                res.getInteger(R.integer.config_customizeZoomInTime);
2673
2674        final float scale = toAllApps ?
2675                (float) res.getInteger(R.integer.config_allAppsZoomScaleFactor) :
2676                (float) res.getInteger(R.integer.config_customizeZoomScaleFactor);
2677
2678        final View toView = toAllApps ? (View) mAllAppsGrid : mHomeCustomizationDrawer;
2679
2680        setPivotsForZoom(toView, toState, scale);
2681
2682        if (toAllApps) {
2683            mWorkspace.shrink(ShrinkState.BOTTOM_HIDDEN, animated);
2684            toView.setAlpha(0f);
2685        } else {
2686            mWorkspace.shrink(ShrinkState.TOP, animated);
2687        }
2688
2689        if (animated) {
2690            ValueAnimator scaleAnim = ObjectAnimator.ofPropertyValuesHolder(toView,
2691                    PropertyValuesHolder.ofFloat("scaleX", scale, 1.0f),
2692                    PropertyValuesHolder.ofFloat("scaleY", scale, 1.0f));
2693
2694            scaleAnim.setDuration(duration);
2695
2696            if (toAllApps) {
2697                ObjectAnimator alphaAnim = ObjectAnimator.ofPropertyValuesHolder(toView,
2698                        PropertyValuesHolder.ofFloat("alpha", 1.0f));
2699                alphaAnim.setInterpolator(new DecelerateInterpolator(1.5f));
2700                alphaAnim.setDuration(duration);
2701                alphaAnim.start();
2702            }
2703
2704            scaleAnim.setInterpolator(new Workspace.ZoomOutInterpolator());
2705            scaleAnim.addListener(new AnimatorListenerAdapter() {
2706                @Override
2707                public void onAnimationStart(Animator animation) {
2708                    // Prepare the position
2709                    toView.setTranslationX(0.0f);
2710                    toView.setTranslationY(0.0f);
2711                    toView.setVisibility(View.VISIBLE);
2712                    if (!toAllApps) {
2713                        toView.setAlpha(1.0f);
2714                    }
2715                }
2716                @Override
2717                public void onAnimationEnd(Animator animation) {
2718                    // If we don't set the final scale values here, if this animation is cancelled
2719                    // it will have the wrong scale value and subsequent cameraPan animations will
2720                    // not fix that
2721                    toView.setScaleX(1.0f);
2722                    toView.setScaleY(1.0f);
2723                }
2724            });
2725
2726            AnimatorSet toolbarHideAnim = new AnimatorSet();
2727            AnimatorSet toolbarShowAnim = new AnimatorSet();
2728            hideAndShowToolbarButtons(toState, toolbarShowAnim, toolbarHideAnim);
2729
2730            // toView should appear right at the end of the workspace shrink animation
2731            final int startDelay = 0;
2732
2733            if (mStateAnimation != null) mStateAnimation.cancel();
2734            mStateAnimation = new AnimatorSet();
2735            mStateAnimation.playTogether(scaleAnim, toolbarHideAnim);
2736            mStateAnimation.play(scaleAnim).after(startDelay);
2737
2738            // Show the new toolbar buttons just as the main animation is ending
2739            final int fadeInTime = res.getInteger(R.integer.config_toolbarButtonFadeInTime);
2740            mStateAnimation.play(toolbarShowAnim).after(duration + startDelay - fadeInTime);
2741            mStateAnimation.start();
2742        } else {
2743            toView.setTranslationX(0.0f);
2744            toView.setTranslationY(0.0f);
2745            toView.setScaleX(1.0f);
2746            toView.setScaleY(1.0f);
2747            toView.setVisibility(View.VISIBLE);
2748            hideAndShowToolbarButtons(toState, null, null);
2749        }
2750        mWorkspace.setVerticalWallpaperOffset(toAllApps ?
2751                Workspace.WallpaperVerticalOffset.TOP  : Workspace.WallpaperVerticalOffset.BOTTOM);
2752    }
2753
2754    /**
2755     * Zoom the camera back into the workspace, hiding 'fromView'.
2756     * This is the opposite of cameraZoomOut.
2757     * @param fromState The current state (must be ALL_APPS or CUSTOMIZE).
2758     * @param animated If true, the transition will be animated.
2759     */
2760    private void cameraZoomIn(State fromState, boolean animated) {
2761        cameraZoomIn(fromState, animated, false);
2762    }
2763
2764    private void cameraZoomIn(State fromState, boolean animated, boolean springLoaded) {
2765        Resources res = getResources();
2766        final boolean fromAllApps = (fromState == State.ALL_APPS);
2767
2768        int duration = fromAllApps ?
2769            res.getInteger(R.integer.config_allAppsZoomOutTime) :
2770            res.getInteger(R.integer.config_customizeZoomOutTime);
2771
2772        float scaleFactor = fromAllApps ?
2773            (float) res.getInteger(R.integer.config_allAppsZoomScaleFactor) :
2774            (float) res.getInteger(R.integer.config_customizeZoomScaleFactor);
2775
2776        final View fromView = fromAllApps ? (View) mAllAppsGrid : mHomeCustomizationDrawer;
2777
2778        mCustomizePagedView.endChoiceMode();
2779        mAllAppsPagedView.endChoiceMode();
2780
2781        setPivotsForZoom(fromView, fromState, scaleFactor);
2782
2783        if (!springLoaded) {
2784            mWorkspace.unshrink(animated);
2785        }
2786
2787        if (animated) {
2788            if (mStateAnimation != null) mStateAnimation.cancel();
2789            mStateAnimation = new AnimatorSet();
2790            ValueAnimator scaleAnim = ObjectAnimator.ofPropertyValuesHolder(fromView,
2791                    PropertyValuesHolder.ofFloat("scaleX", scaleFactor),
2792                    PropertyValuesHolder.ofFloat("scaleY", scaleFactor));
2793            scaleAnim.setDuration(duration);
2794            scaleAnim.setInterpolator(new Workspace.ZoomInInterpolator());
2795
2796            ValueAnimator alphaAnim = ObjectAnimator.ofPropertyValuesHolder(fromView,
2797                    PropertyValuesHolder.ofFloat("alpha", 1.0f, 0.0f));
2798            alphaAnim.setDuration(res.getInteger(R.integer.config_allAppsFadeOutTime));
2799            alphaAnim.setInterpolator(new DecelerateInterpolator(1.5f));
2800            alphaAnim.addListener(new AnimatorListenerAdapter() {
2801                @Override
2802                public void onAnimationEnd(Animator animation) {
2803                    fromView.setVisibility(View.GONE);
2804                }
2805            });
2806
2807            AnimatorSet toolbarHideAnim = new AnimatorSet();
2808            AnimatorSet toolbarShowAnim = new AnimatorSet();
2809            if (!springLoaded) {
2810                hideAndShowToolbarButtons(State.WORKSPACE, toolbarShowAnim, toolbarHideAnim);
2811            }
2812
2813            mStateAnimation.playTogether(scaleAnim, toolbarHideAnim, alphaAnim);
2814
2815            // Show the new toolbar buttons at the very end of the whole animation
2816            final int fadeInTime = res.getInteger(R.integer.config_toolbarButtonFadeInTime);
2817            final int unshrinkTime = res.getInteger(R.integer.config_workspaceUnshrinkTime);
2818            mStateAnimation.play(toolbarShowAnim).after(unshrinkTime - fadeInTime);
2819            mStateAnimation.start();
2820        } else {
2821            fromView.setVisibility(View.GONE);
2822            if (!springLoaded) {
2823                hideAndShowToolbarButtons(State.WORKSPACE, null, null);
2824            }
2825        }
2826        mWorkspace.setVerticalWallpaperOffset(Workspace.WallpaperVerticalOffset.MIDDLE);
2827    }
2828
2829    /**
2830     * Pan the camera in the vertical plane between 'fromView' and 'toView'.
2831     * This is the transition used on xlarge screens to go between all apps and
2832     * the home customization drawer.
2833     * @param fromState The view to pan away from. Must be ALL_APPS or CUSTOMIZE.
2834     * @param toState The view to pan into the frame. Must be ALL_APPS or CUSTOMIZE.
2835     * @param animated If true, the transition will be animated.
2836     */
2837    private void cameraPan(State fromState, State toState, boolean animated) {
2838        final Resources res = getResources();
2839        final int duration = res.getInteger(R.integer.config_allAppsCameraPanTime);
2840        final int workspaceHeight = mWorkspace.getHeight();
2841
2842        final boolean fromAllApps = (fromState == State.ALL_APPS);
2843        final View fromView = fromAllApps ? (View) mAllAppsGrid : mHomeCustomizationDrawer;
2844        final View toView = fromAllApps ? mHomeCustomizationDrawer : (View) mAllAppsGrid;
2845
2846        final float fromViewStartY = fromAllApps ? 0.0f : fromView.getY();
2847        final float fromViewEndY = fromAllApps ? -fromView.getHeight() * 2 : workspaceHeight * 2;
2848        final float toViewStartY = fromAllApps ? workspaceHeight * 2 : -toView.getHeight() * 2;
2849        final float toViewEndY = fromAllApps ? workspaceHeight - toView.getHeight() : 0.0f;
2850
2851        mCustomizePagedView.endChoiceMode();
2852        mAllAppsPagedView.endChoiceMode();
2853
2854        if (toState == State.ALL_APPS) {
2855            mWorkspace.shrink(Workspace.ShrinkState.BOTTOM_HIDDEN, animated);
2856        } else {
2857            mWorkspace.shrink(Workspace.ShrinkState.TOP, animated);
2858        }
2859
2860        if (animated) {
2861            if (mStateAnimation != null) mStateAnimation.cancel();
2862            mStateAnimation = new AnimatorSet();
2863            mStateAnimation.addListener(new AnimatorListenerAdapter() {
2864                @Override
2865                public void onAnimationStart(Animator animation) {
2866                    toView.setVisibility(View.VISIBLE);
2867                    toView.setY(toViewStartY);
2868                    toView.setAlpha(1.0f);
2869                }
2870                @Override
2871                public void onAnimationEnd(Animator animation) {
2872                    fromView.setVisibility(View.GONE);
2873                }
2874            });
2875
2876            AnimatorSet toolbarHideAnim = new AnimatorSet();
2877            AnimatorSet toolbarShowAnim = new AnimatorSet();
2878            hideAndShowToolbarButtons(toState, toolbarShowAnim, toolbarHideAnim);
2879
2880            ObjectAnimator fromAnim = ObjectAnimator.ofFloat(fromView, "y",
2881                    fromViewStartY, fromViewEndY);
2882            fromAnim.setDuration(duration);
2883            ObjectAnimator toAnim = ObjectAnimator.ofPropertyValuesHolder(toView,
2884                    PropertyValuesHolder.ofFloat("y", toViewStartY, toViewEndY),
2885                    PropertyValuesHolder.ofFloat("scaleX", toView.getScaleX(), 1.0f),
2886                    PropertyValuesHolder.ofFloat("scaleY", toView.getScaleY(), 1.0f)
2887                    );
2888            fromAnim.setDuration(duration);
2889            mStateAnimation.playTogether(toolbarHideAnim, fromAnim, toAnim);
2890
2891            // Show the new toolbar buttons just as the main animation is ending
2892            final int fadeInTime = res.getInteger(R.integer.config_toolbarButtonFadeInTime);
2893            mStateAnimation.play(toolbarShowAnim).after(duration - fadeInTime);
2894            mStateAnimation.start();
2895        } else {
2896            fromView.setY(fromViewEndY);
2897            fromView.setVisibility(View.GONE);
2898            toView.setY(toViewEndY);
2899            toView.setScaleX(1.0f);
2900            toView.setScaleY(1.0f);
2901            toView.setVisibility(View.VISIBLE);
2902            hideAndShowToolbarButtons(toState, null, null);
2903        }
2904        mWorkspace.setVerticalWallpaperOffset((toState == State.ALL_APPS) ?
2905                Workspace.WallpaperVerticalOffset.TOP : Workspace.WallpaperVerticalOffset.BOTTOM);
2906    }
2907
2908    void showAllApps(boolean animated) {
2909        if (mState == State.ALL_APPS) {
2910            return;
2911        }
2912
2913        if (LauncherApplication.isScreenXLarge()) {
2914            if (mState == State.CUSTOMIZE) {
2915                cameraPan(State.CUSTOMIZE, State.ALL_APPS, animated);
2916            } else {
2917                cameraZoomOut(State.ALL_APPS, animated);
2918            }
2919        } else {
2920            mAllAppsGrid.zoom(1.0f, animated);
2921        }
2922
2923        ((View) mAllAppsGrid).setFocusable(true);
2924        ((View) mAllAppsGrid).requestFocus();
2925
2926        // TODO: fade these two too
2927        mDeleteZone.setVisibility(View.GONE);
2928
2929        // Change the state *after* we've called all the transition code
2930        mState = State.ALL_APPS;
2931
2932        // send an accessibility event to announce the context change
2933        getWindow().getDecorView().sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_SELECTED);
2934    }
2935
2936    void showWorkspace(boolean animated) {
2937        showWorkspace(animated, null);
2938    }
2939
2940    void showWorkspace(boolean animated, CellLayout layout) {
2941        if (layout != null) {
2942            // always animated, but that's ok since we never specify a layout and
2943            // want no animation
2944            mWorkspace.unshrink(layout);
2945        } else {
2946            mWorkspace.unshrink(animated);
2947        }
2948        if (mState == State.ALL_APPS) {
2949            closeAllApps(animated);
2950        } else if (mState == State.CUSTOMIZE) {
2951            hideCustomizationDrawer(animated);
2952        }
2953
2954        // Change the state *after* we've called all the transition code
2955        mState = State.WORKSPACE;
2956
2957        // send an accessibility event to announce the context change
2958        getWindow().getDecorView().sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_SELECTED);
2959    }
2960
2961    void enterSpringLoadedDragMode(CellLayout layout) {
2962        mWorkspace.enterSpringLoadedDragMode(layout);
2963        if (mState == State.ALL_APPS) {
2964            cameraZoomIn(State.ALL_APPS, true, true);
2965            mState = State.ALL_APPS_SPRING_LOADED;
2966        } else if (mState == State.CUSTOMIZE) {
2967            cameraZoomIn(State.CUSTOMIZE, true, true);
2968            mState = State.CUSTOMIZE_SPRING_LOADED;
2969        }/* else {
2970            // we're already in spring loaded mode; don't do anything
2971        }*/
2972    }
2973
2974    void exitSpringLoadedDragMode() {
2975        if (mState == State.ALL_APPS_SPRING_LOADED) {
2976            mWorkspace.exitSpringLoadedDragMode(Workspace.ShrinkState.BOTTOM_VISIBLE);
2977            cameraZoomOut(State.ALL_APPS, true);
2978            mState = State.ALL_APPS;
2979        } else if (mState == State.CUSTOMIZE_SPRING_LOADED) {
2980            mWorkspace.exitSpringLoadedDragMode(Workspace.ShrinkState.TOP);
2981            cameraZoomOut(State.CUSTOMIZE, true);
2982            mState = State.CUSTOMIZE;
2983        }/* else {
2984            // we're not in spring loaded mode; don't do anything
2985        }*/
2986    }
2987
2988    /**
2989     * Things to test when changing this code.
2990     *   - Home from workspace
2991     *          - from center screen
2992     *          - from other screens
2993     *   - Home from all apps
2994     *          - from center screen
2995     *          - from other screens
2996     *   - Back from all apps
2997     *          - from center screen
2998     *          - from other screens
2999     *   - Launch app from workspace and quit
3000     *          - with back
3001     *          - with home
3002     *   - Launch app from all apps and quit
3003     *          - with back
3004     *          - with home
3005     *   - Go to a screen that's not the default, then all
3006     *     apps, and launch and app, and go back
3007     *          - with back
3008     *          -with home
3009     *   - On workspace, long press power and go back
3010     *          - with back
3011     *          - with home
3012     *   - On all apps, long press power and go back
3013     *          - with back
3014     *          - with home
3015     *   - On workspace, power off
3016     *   - On all apps, power off
3017     *   - Launch an app and turn off the screen while in that app
3018     *          - Go back with home key
3019     *          - Go back with back key  TODO: make this not go to workspace
3020     *          - From all apps
3021     *          - From workspace
3022     *   - Enter and exit car mode (becuase it causes an extra configuration changed)
3023     *          - From all apps
3024     *          - From the center workspace
3025     *          - From another workspace
3026     */
3027    void closeAllApps(boolean animated) {
3028        if (mState == State.ALL_APPS || mState == State.ALL_APPS_SPRING_LOADED) {
3029            mWorkspace.setVisibility(View.VISIBLE);
3030            if (LauncherApplication.isScreenXLarge()) {
3031                cameraZoomIn(State.ALL_APPS, animated);
3032            } else {
3033                mAllAppsGrid.zoom(0.0f, animated);
3034            }
3035            ((View)mAllAppsGrid).setFocusable(false);
3036            mWorkspace.getChildAt(mWorkspace.getCurrentPage()).requestFocus();
3037        }
3038    }
3039
3040    void lockAllApps() {
3041        // TODO
3042    }
3043
3044    void unlockAllApps() {
3045        // TODO
3046    }
3047
3048    // Show the customization drawer (only exists in x-large configuration)
3049    private void showCustomizationDrawer(boolean animated) {
3050        if (mState == State.ALL_APPS) {
3051            cameraPan(State.ALL_APPS, State.CUSTOMIZE, animated);
3052        } else {
3053            cameraZoomOut(State.CUSTOMIZE, animated);
3054        }
3055        // Change the state *after* we've called all the transition code
3056        mState = State.CUSTOMIZE;
3057    }
3058
3059    // Hide the customization drawer (only exists in x-large configuration)
3060    void hideCustomizationDrawer(boolean animated) {
3061        if (mState == State.CUSTOMIZE || mState == State.CUSTOMIZE_SPRING_LOADED) {
3062            cameraZoomIn(State.CUSTOMIZE, animated);
3063        }
3064    }
3065
3066    void addExternalItemToScreen(ItemInfo itemInfo, CellLayout layout) {
3067        if (!mWorkspace.addExternalItemToScreen(itemInfo, layout)) {
3068            showOutOfSpaceMessage();
3069        }
3070    }
3071
3072    void onWorkspaceClick(CellLayout layout) {
3073        showWorkspace(true, layout);
3074    }
3075
3076    // if successful in getting icon, return it; otherwise, set button to use default drawable
3077    private Drawable.ConstantState updateButtonWithIconFromExternalActivity(
3078            int buttonId, ComponentName activityName, int fallbackDrawableId) {
3079        ImageView button = (ImageView) findViewById(buttonId);
3080        Drawable toolbarIcon = null;
3081        try {
3082            PackageManager packageManager = getPackageManager();
3083            // Look for the toolbar icon specified in the activity meta-data
3084            Bundle metaData = packageManager.getActivityInfo(
3085                    activityName, PackageManager.GET_META_DATA).metaData;
3086            if (metaData != null) {
3087                int iconResId = metaData.getInt(TOOLBAR_ICON_METADATA_NAME);
3088                if (iconResId != 0) {
3089                    Resources res = packageManager.getResourcesForActivity(activityName);
3090                    toolbarIcon = res.getDrawable(iconResId);
3091                }
3092            }
3093        } catch (NameNotFoundException e) {
3094            // Do nothing
3095        }
3096        // If we were unable to find the icon via the meta-data, use a generic one
3097        if (toolbarIcon == null) {
3098            button.setImageResource(fallbackDrawableId);
3099            return null;
3100        } else {
3101            button.setImageDrawable(toolbarIcon);
3102            return toolbarIcon.getConstantState();
3103        }
3104    }
3105
3106    private void updateButtonWithDrawable(int buttonId, Drawable.ConstantState d) {
3107        ImageView button = (ImageView) findViewById(buttonId);
3108        button.setImageDrawable(d.newDrawable(getResources()));
3109    }
3110
3111    private void updateGlobalSearchIcon() {
3112        if (LauncherApplication.isScreenXLarge()) {
3113            final SearchManager searchManager =
3114                    (SearchManager) getSystemService(Context.SEARCH_SERVICE);
3115            ComponentName activityName = searchManager.getGlobalSearchActivity();
3116            if (activityName != null) {
3117                sGlobalSearchIcon = updateButtonWithIconFromExternalActivity(
3118                        R.id.search_button, activityName, R.drawable.search_button_generic);
3119            } else {
3120                findViewById(R.id.search_button).setVisibility(View.GONE);
3121            }
3122        }
3123    }
3124
3125    private void updateGlobalSearchIcon(Drawable.ConstantState d) {
3126        updateButtonWithDrawable(R.id.search_button, d);
3127    }
3128
3129    private void updateVoiceSearchIcon() {
3130        if (LauncherApplication.isScreenXLarge()) {
3131            Intent intent = new Intent(RecognizerIntent.ACTION_WEB_SEARCH);
3132            ComponentName activityName = intent.resolveActivity(getPackageManager());
3133            if (activityName != null) {
3134                sVoiceSearchIcon = updateButtonWithIconFromExternalActivity(
3135                        R.id.voice_button, activityName, R.drawable.ic_voice_search);
3136            } else {
3137                findViewById(R.id.voice_button).setVisibility(View.GONE);
3138            }
3139        }
3140    }
3141
3142    private void updateVoiceSearchIcon(Drawable.ConstantState d) {
3143        updateButtonWithDrawable(R.id.voice_button, d);
3144    }
3145
3146    /**
3147     * Sets the app market icon (shown when all apps is visible on x-large screens)
3148     */
3149    private void updateAppMarketIcon() {
3150        if (LauncherApplication.isScreenXLarge()) {
3151            Intent intent = new Intent(Intent.ACTION_MAIN).addCategory(Intent.CATEGORY_APP_MARKET);
3152            // Find the app market activity by resolving an intent.
3153            // (If multiple app markets are installed, it will return the ResolverActivity.)
3154            ComponentName activityName = intent.resolveActivity(getPackageManager());
3155            if (activityName != null) {
3156                mAppMarketIntent = intent;
3157                sAppMarketIcon = updateButtonWithIconFromExternalActivity(
3158                        R.id.market_button, activityName, R.drawable.app_market_generic);
3159            }
3160        }
3161    }
3162
3163    private void updateAppMarketIcon(Drawable.ConstantState d) {
3164        updateButtonWithDrawable(R.id.market_button, d);
3165    }
3166
3167    /**
3168     * Displays the shortcut creation dialog and launches, if necessary, the
3169     * appropriate activity.
3170     */
3171    private class CreateShortcut implements DialogInterface.OnClickListener,
3172            DialogInterface.OnCancelListener, DialogInterface.OnDismissListener,
3173            DialogInterface.OnShowListener {
3174
3175        private AddAdapter mAdapter;
3176
3177        Dialog createDialog() {
3178            mAdapter = new AddAdapter(Launcher.this);
3179
3180            final AlertDialog.Builder builder = new AlertDialog.Builder(Launcher.this);
3181            builder.setTitle(getString(R.string.menu_item_add_item));
3182            builder.setAdapter(mAdapter, this);
3183
3184            builder.setInverseBackgroundForced(true);
3185
3186            AlertDialog dialog = builder.create();
3187            dialog.setOnCancelListener(this);
3188            dialog.setOnDismissListener(this);
3189            dialog.setOnShowListener(this);
3190
3191            return dialog;
3192        }
3193
3194        public void onCancel(DialogInterface dialog) {
3195            mWaitingForResult = false;
3196            cleanup();
3197        }
3198
3199        public void onDismiss(DialogInterface dialog) {
3200        }
3201
3202        private void cleanup() {
3203            try {
3204                dismissDialog(DIALOG_CREATE_SHORTCUT);
3205            } catch (Exception e) {
3206                // An exception is thrown if the dialog is not visible, which is fine
3207            }
3208        }
3209
3210        /**
3211         * Handle the action clicked in the "Add to home" dialog.
3212         */
3213        public void onClick(DialogInterface dialog, int which) {
3214            Resources res = getResources();
3215            cleanup();
3216
3217            switch (which) {
3218                case AddAdapter.ITEM_SHORTCUT: {
3219                    pickShortcut();
3220                    break;
3221                }
3222
3223                case AddAdapter.ITEM_APPWIDGET: {
3224                    int appWidgetId = Launcher.this.mAppWidgetHost.allocateAppWidgetId();
3225
3226                    Intent pickIntent = new Intent(AppWidgetManager.ACTION_APPWIDGET_PICK);
3227                    pickIntent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId);
3228                    // start the pick activity
3229                    startActivityForResult(pickIntent, REQUEST_PICK_APPWIDGET);
3230                    break;
3231                }
3232
3233                case AddAdapter.ITEM_LIVE_FOLDER: {
3234                    // Insert extra item to handle inserting folder
3235                    Bundle bundle = new Bundle();
3236
3237                    ArrayList<String> shortcutNames = new ArrayList<String>();
3238                    shortcutNames.add(res.getString(R.string.group_folder));
3239                    bundle.putStringArrayList(Intent.EXTRA_SHORTCUT_NAME, shortcutNames);
3240
3241                    ArrayList<ShortcutIconResource> shortcutIcons =
3242                            new ArrayList<ShortcutIconResource>();
3243                    shortcutIcons.add(ShortcutIconResource.fromContext(Launcher.this,
3244                            R.drawable.ic_launcher_folder));
3245                    bundle.putParcelableArrayList(Intent.EXTRA_SHORTCUT_ICON_RESOURCE, shortcutIcons);
3246
3247                    Intent pickIntent = new Intent(Intent.ACTION_PICK_ACTIVITY);
3248                    pickIntent.putExtra(Intent.EXTRA_INTENT,
3249                            new Intent(LiveFolders.ACTION_CREATE_LIVE_FOLDER));
3250                    pickIntent.putExtra(Intent.EXTRA_TITLE,
3251                            getText(R.string.title_select_live_folder));
3252                    pickIntent.putExtras(bundle);
3253
3254                    startActivityForResult(pickIntent, REQUEST_PICK_LIVE_FOLDER);
3255                    break;
3256                }
3257
3258                case AddAdapter.ITEM_WALLPAPER: {
3259                    startWallpaper();
3260                    break;
3261                }
3262            }
3263        }
3264
3265        public void onShow(DialogInterface dialog) {
3266            mWaitingForResult = true;
3267        }
3268    }
3269
3270    /**
3271     * Receives notifications when applications are added/removed.
3272     */
3273    private class CloseSystemDialogsIntentReceiver extends BroadcastReceiver {
3274        @Override
3275        public void onReceive(Context context, Intent intent) {
3276            closeSystemDialogs();
3277            String reason = intent.getStringExtra("reason");
3278            if (!"homekey".equals(reason)) {
3279                boolean animate = true;
3280                if (mPaused || "lock".equals(reason)) {
3281                    animate = false;
3282                }
3283                showWorkspace(animate);
3284            }
3285        }
3286    }
3287
3288    /**
3289     * Receives notifications whenever the appwidgets are reset.
3290     */
3291    private class AppWidgetResetObserver extends ContentObserver {
3292        public AppWidgetResetObserver() {
3293            super(new Handler());
3294        }
3295
3296        @Override
3297        public void onChange(boolean selfChange) {
3298            onAppWidgetReset();
3299        }
3300    }
3301
3302    /**
3303     * If the activity is currently paused, signal that we need to re-run the loader
3304     * in onResume.
3305     *
3306     * This needs to be called from incoming places where resources might have been loaded
3307     * while we are paused.  That is becaues the Configuration might be wrong
3308     * when we're not running, and if it comes back to what it was when we
3309     * were paused, we are not restarted.
3310     *
3311     * Implementation of the method from LauncherModel.Callbacks.
3312     *
3313     * @return true if we are currently paused.  The caller might be able to
3314     * skip some work in that case since we will come back again.
3315     */
3316    public boolean setLoadOnResume() {
3317        if (mPaused) {
3318            Log.i(TAG, "setLoadOnResume");
3319            mOnResumeNeedsLoad = true;
3320            return true;
3321        } else {
3322            return false;
3323        }
3324    }
3325
3326    /**
3327     * Implementation of the method from LauncherModel.Callbacks.
3328     */
3329    public int getCurrentWorkspaceScreen() {
3330        if (mWorkspace != null) {
3331            return mWorkspace.getCurrentPage();
3332        } else {
3333            return SCREEN_COUNT / 2;
3334        }
3335    }
3336
3337    void setAllAppsPagedView(AllAppsPagedView view) {
3338        mAllAppsPagedView = view;
3339    }
3340
3341    /**
3342     * Refreshes the shortcuts shown on the workspace.
3343     *
3344     * Implementation of the method from LauncherModel.Callbacks.
3345     */
3346    public void startBinding() {
3347        final Workspace workspace = mWorkspace;
3348        int count = workspace.getChildCount();
3349        for (int i = 0; i < count; i++) {
3350            // Use removeAllViewsInLayout() to avoid an extra requestLayout() and invalidate().
3351            ((ViewGroup) workspace.getChildAt(i)).removeAllViewsInLayout();
3352        }
3353
3354        if (DEBUG_USER_INTERFACE) {
3355            android.widget.Button finishButton = new android.widget.Button(this);
3356            finishButton.setText("Finish");
3357            workspace.addInScreen(finishButton, 1, 0, 0, 1, 1);
3358
3359            finishButton.setOnClickListener(new android.widget.Button.OnClickListener() {
3360                public void onClick(View v) {
3361                    finish();
3362                }
3363            });
3364        }
3365    }
3366
3367    /**
3368     * Bind the items start-end from the list.
3369     *
3370     * Implementation of the method from LauncherModel.Callbacks.
3371     */
3372    public void bindItems(ArrayList<ItemInfo> shortcuts, int start, int end) {
3373
3374        setLoadOnResume();
3375
3376        final Workspace workspace = mWorkspace;
3377
3378        for (int i=start; i<end; i++) {
3379            final ItemInfo item = shortcuts.get(i);
3380            mDesktopItems.add(item);
3381            switch (item.itemType) {
3382                case LauncherSettings.Favorites.ITEM_TYPE_APPLICATION:
3383                case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT:
3384                    final View shortcut = createShortcut((ShortcutInfo)item);
3385                    workspace.addInScreen(shortcut, item.screen, item.cellX, item.cellY, 1, 1,
3386                            false);
3387                    break;
3388                case LauncherSettings.Favorites.ITEM_TYPE_USER_FOLDER:
3389                    final FolderIcon newFolder = FolderIcon.fromXml(R.layout.folder_icon, this,
3390                            (ViewGroup) workspace.getChildAt(workspace.getCurrentPage()),
3391                            (UserFolderInfo) item, mIconCache);
3392                    workspace.addInScreen(newFolder, item.screen, item.cellX, item.cellY, 1, 1,
3393                            false);
3394                    break;
3395                case LauncherSettings.Favorites.ITEM_TYPE_LIVE_FOLDER:
3396                    final FolderIcon newLiveFolder = LiveFolderIcon.fromXml(
3397                            R.layout.live_folder_icon, this,
3398                            (ViewGroup) workspace.getChildAt(workspace.getCurrentPage()),
3399                            (LiveFolderInfo) item);
3400                    workspace.addInScreen(newLiveFolder, item.screen, item.cellX, item.cellY, 1, 1,
3401                            false);
3402                    break;
3403            }
3404        }
3405
3406        workspace.requestLayout();
3407    }
3408
3409    /**
3410     * Implementation of the method from LauncherModel.Callbacks.
3411     */
3412    public void bindFolders(HashMap<Long, FolderInfo> folders) {
3413        setLoadOnResume();
3414        sFolders.clear();
3415        sFolders.putAll(folders);
3416    }
3417
3418    /**
3419     * Add the views for a widget to the workspace.
3420     *
3421     * Implementation of the method from LauncherModel.Callbacks.
3422     */
3423    public void bindAppWidget(LauncherAppWidgetInfo item) {
3424        setLoadOnResume();
3425
3426        final long start = DEBUG_WIDGETS ? SystemClock.uptimeMillis() : 0;
3427        if (DEBUG_WIDGETS) {
3428            Log.d(TAG, "bindAppWidget: " + item);
3429        }
3430        final Workspace workspace = mWorkspace;
3431
3432        final int appWidgetId = item.appWidgetId;
3433        final AppWidgetProviderInfo appWidgetInfo = mAppWidgetManager.getAppWidgetInfo(appWidgetId);
3434        if (DEBUG_WIDGETS) {
3435            Log.d(TAG, "bindAppWidget: id=" + item.appWidgetId + " belongs to component " + appWidgetInfo.provider);
3436        }
3437
3438        item.hostView = mAppWidgetHost.createView(this, appWidgetId, appWidgetInfo);
3439
3440        item.hostView.setAppWidget(appWidgetId, appWidgetInfo);
3441        item.hostView.setTag(item);
3442
3443        workspace.addInScreen(item.hostView, item.screen, item.cellX,
3444                item.cellY, item.spanX, item.spanY, false);
3445
3446        addWidgetToAutoAdvanceIfNeeded(item.hostView, appWidgetInfo);
3447
3448        workspace.requestLayout();
3449
3450        mDesktopItems.add(item);
3451
3452        if (DEBUG_WIDGETS) {
3453            Log.d(TAG, "bound widget id="+item.appWidgetId+" in "
3454                    + (SystemClock.uptimeMillis()-start) + "ms");
3455        }
3456    }
3457
3458    /**
3459     * Callback saying that there aren't any more items to bind.
3460     *
3461     * Implementation of the method from LauncherModel.Callbacks.
3462     */
3463    public void finishBindingItems() {
3464        setLoadOnResume();
3465
3466        if (mSavedState != null) {
3467            if (!mWorkspace.hasFocus()) {
3468                mWorkspace.getChildAt(mWorkspace.getCurrentPage()).requestFocus();
3469            }
3470
3471            final long[] userFolders = mSavedState.getLongArray(RUNTIME_STATE_USER_FOLDERS);
3472            if (userFolders != null) {
3473                for (long folderId : userFolders) {
3474                    final FolderInfo info = sFolders.get(folderId);
3475                    if (info != null) {
3476                        openFolder(info);
3477                    }
3478                }
3479                final Folder openFolder = mWorkspace.getOpenFolder();
3480                if (openFolder != null) {
3481                    openFolder.requestFocus();
3482                }
3483            }
3484
3485            mSavedState = null;
3486        }
3487
3488        if (mSavedInstanceState != null) {
3489            super.onRestoreInstanceState(mSavedInstanceState);
3490            mSavedInstanceState = null;
3491        }
3492
3493        mWorkspaceLoading = false;
3494    }
3495
3496    /**
3497     * Updates the icons on the launcher that are affected by changes to the package list
3498     * on the device.
3499     */
3500    private void updateIconsAffectedByPackageManagerChanges() {
3501        updateAppMarketIcon();
3502        updateGlobalSearchIcon();
3503        updateVoiceSearchIcon();
3504    }
3505
3506    /**
3507     * Add the icons for all apps.
3508     *
3509     * Implementation of the method from LauncherModel.Callbacks.
3510     */
3511    public void bindAllApplications(ArrayList<ApplicationInfo> apps) {
3512        mAllAppsGrid.setApps(apps);
3513        if (mCustomizePagedView != null) {
3514            mCustomizePagedView.setApps(apps);
3515        }
3516        updateIconsAffectedByPackageManagerChanges();
3517    }
3518
3519    /**
3520     * A package was installed.
3521     *
3522     * Implementation of the method from LauncherModel.Callbacks.
3523     */
3524    public void bindAppsAdded(ArrayList<ApplicationInfo> apps) {
3525        setLoadOnResume();
3526        removeDialog(DIALOG_CREATE_SHORTCUT);
3527        mAllAppsGrid.addApps(apps);
3528        if (mCustomizePagedView != null) {
3529            mCustomizePagedView.addApps(apps);
3530        }
3531        updateIconsAffectedByPackageManagerChanges();
3532    }
3533
3534    /**
3535     * A package was updated.
3536     *
3537     * Implementation of the method from LauncherModel.Callbacks.
3538     */
3539    public void bindAppsUpdated(ArrayList<ApplicationInfo> apps) {
3540        setLoadOnResume();
3541        removeDialog(DIALOG_CREATE_SHORTCUT);
3542        mWorkspace.updateShortcuts(apps);
3543        mAllAppsGrid.updateApps(apps);
3544        if (mCustomizePagedView != null) {
3545            mCustomizePagedView.updateApps(apps);
3546        }
3547        updateIconsAffectedByPackageManagerChanges();
3548    }
3549
3550    /**
3551     * A package was uninstalled.
3552     *
3553     * Implementation of the method from LauncherModel.Callbacks.
3554     */
3555    public void bindAppsRemoved(ArrayList<ApplicationInfo> apps, boolean permanent) {
3556        removeDialog(DIALOG_CREATE_SHORTCUT);
3557        if (permanent) {
3558            mWorkspace.removeItems(apps);
3559        }
3560        mAllAppsGrid.removeApps(apps);
3561        if (mCustomizePagedView != null) {
3562            mCustomizePagedView.removeApps(apps);
3563        }
3564        updateIconsAffectedByPackageManagerChanges();
3565    }
3566
3567    /**
3568     * A number of packages were updated.
3569     */
3570    public void bindPackagesUpdated() {
3571        // update the customization drawer contents
3572        if (mCustomizePagedView != null) {
3573            mCustomizePagedView.update();
3574        }
3575    }
3576
3577    /**
3578     * Prints out out state for debugging.
3579     */
3580    public void dumpState() {
3581        Log.d(TAG, "BEGIN launcher2 dump state for launcher " + this);
3582        Log.d(TAG, "mSavedState=" + mSavedState);
3583        Log.d(TAG, "mWorkspaceLoading=" + mWorkspaceLoading);
3584        Log.d(TAG, "mRestoring=" + mRestoring);
3585        Log.d(TAG, "mWaitingForResult=" + mWaitingForResult);
3586        Log.d(TAG, "mSavedInstanceState=" + mSavedInstanceState);
3587        Log.d(TAG, "mDesktopItems.size=" + mDesktopItems.size());
3588        Log.d(TAG, "sFolders.size=" + sFolders.size());
3589        mModel.dumpState();
3590        mAllAppsGrid.dumpState();
3591        Log.d(TAG, "END launcher2 dump state");
3592    }
3593}
3594