blob: f1d4c1d9bdbc5360ea94d53d58144696a5041681 [file] [log] [blame]
Michael Jurka01f0ed42010-08-20 00:41:17 -07001
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002/*
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
Daniel Sandler325dc232013-06-05 22:57:57 -040018package com.android.launcher3;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080019
Michael Jurka974c3862012-05-22 22:00:31 -070020import android.accounts.Account;
21import android.accounts.AccountManager;
Gilles Debunnedd6c9922010-10-25 11:23:41 -070022import android.animation.Animator;
Michael Jurka8edd75c2010-12-17 20:15:06 -080023import android.animation.AnimatorListenerAdapter;
Gilles Debunnedd6c9922010-10-25 11:23:41 -070024import android.animation.AnimatorSet;
Adam Cohen2801caf2011-05-13 20:57:39 -070025import android.animation.ObjectAnimator;
26import android.animation.PropertyValuesHolder;
Gilles Debunnedd6c9922010-10-25 11:23:41 -070027import android.animation.ValueAnimator;
Winson Chung70442722012-02-10 15:43:22 -080028import android.animation.ValueAnimator.AnimatorUpdateListener;
Michael Jurka946ad472010-07-09 18:05:18 -070029import android.app.Activity;
Brett Chabot2a9e2282011-08-23 15:03:13 -070030import android.app.ActivityManager;
Winson Chungc7450e32012-04-17 17:34:08 -070031import android.app.ActivityOptions;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080032import android.app.SearchManager;
Adam Cohen0cf2a7c2011-11-08 15:07:01 -080033import android.appwidget.AppWidgetHostView;
Michael Jurkaaf442092010-06-10 17:01:57 -070034import android.appwidget.AppWidgetManager;
35import android.appwidget.AppWidgetProviderInfo;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080036import android.content.ActivityNotFoundException;
Joe Onorato2ca0ae72009-11-10 13:14:13 -080037import android.content.BroadcastReceiver;
Michael Jurkae326f182011-11-21 14:05:46 -080038import android.content.ComponentCallbacks2;
Daniel Sandlerc9b18772010-04-22 14:37:59 -040039import android.content.ComponentName;
Jeff Sharkey1e2efc82009-11-06 15:17:59 -080040import android.content.ContentResolver;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080041import android.content.Context;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080042import android.content.Intent;
Winson Chungf0ea4d32011-06-06 14:27:16 -070043import android.content.IntentFilter;
Winson Chung82f55532011-08-09 14:14:23 -070044import android.content.SharedPreferences;
Winson Chungaafa03c2010-06-11 17:34:16 -070045import android.content.pm.ActivityInfo;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080046import android.content.pm.PackageManager;
Adam Cohen716b51e2011-06-30 12:09:54 -070047import android.content.pm.PackageManager.NameNotFoundException;
Bjorn Bringert85f418d2013-09-06 12:50:05 +010048import android.content.pm.ResolveInfo;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080049import android.content.res.Configuration;
Karl Rosaen138a0412009-04-23 19:00:21 -070050import android.content.res.Resources;
Jeff Sharkey1e2efc82009-11-06 15:17:59 -080051import android.database.ContentObserver;
Adam Cohen268c4752012-06-06 17:47:33 -070052import android.graphics.Bitmap;
53import android.graphics.Canvas;
Winson Chung5f8afe62013-08-12 16:19:28 -070054import android.graphics.Point;
Adam Cohen268c4752012-06-06 17:47:33 -070055import android.graphics.PorterDuff;
Michael Jurkaaf442092010-06-10 17:01:57 -070056import android.graphics.Rect;
Michael Jurkaaf442092010-06-10 17:01:57 -070057import android.graphics.drawable.Drawable;
Daniel Sandlerc9b18772010-04-22 14:37:59 -040058import android.net.Uri;
Brad Fitzpatrick319226a2010-09-01 13:45:16 -070059import android.os.AsyncTask;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080060import android.os.Bundle;
Christian Mehlmauer0fbe7bc2010-08-02 20:27:46 +020061import android.os.Environment;
Jeff Sharkey1e2efc82009-11-06 15:17:59 -080062import android.os.Handler;
Adam Cohended9f8d2010-11-03 13:25:16 -070063import android.os.Message;
Winson Chunga2413752012-04-03 14:22:34 -070064import android.os.StrictMode;
Daniel Sandler843e8602010-06-07 14:59:01 -040065import android.os.SystemClock;
Patrick Dubroy4ed62782010-08-17 15:11:18 -070066import android.provider.Settings;
Amith Yamasani6d7fe502010-11-16 09:05:07 -080067import android.speech.RecognizerIntent;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080068import android.text.Selection;
69import android.text.SpannableStringBuilder;
Michael Jurkaa33411c2012-06-14 16:18:21 -070070import android.text.TextUtils;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080071import android.text.method.TextKeyListener;
Winson Chung892c74d2013-08-22 16:15:50 -070072import android.util.DisplayMetrics;
Joe Onorato7c312c12009-08-13 21:36:53 -070073import android.util.Log;
Adam Cohen96d30a12013-07-16 18:13:21 -070074import android.view.Display;
75import android.view.Gravity;
76import android.view.HapticFeedbackConstants;
77import android.view.KeyEvent;
78import android.view.LayoutInflater;
79import android.view.Menu;
Adam Cohen96d30a12013-07-16 18:13:21 -070080import android.view.MotionEvent;
81import android.view.Surface;
82import android.view.View;
Adam Cohenf358a4b2013-07-23 16:47:31 -070083import android.view.View.OnClickListener;
Adam Cohen0cf2a7c2011-11-08 15:07:01 -080084import android.view.View.OnLongClickListener;
Adam Cohen96d30a12013-07-16 18:13:21 -070085import android.view.ViewGroup;
86import android.view.ViewTreeObserver;
Michael Jurka2a4b1a82011-12-07 14:00:02 -080087import android.view.ViewTreeObserver.OnGlobalLayoutListener;
Adam Cohen96d30a12013-07-16 18:13:21 -070088import android.view.WindowManager;
Svetoslav Ganov815ba2d2011-01-07 14:55:17 -080089import android.view.accessibility.AccessibilityEvent;
Adam Cohencff6af82011-09-13 14:51:53 -070090import android.view.animation.AccelerateDecelerateInterpolator;
Adam Cohenf16e5712011-01-13 13:31:45 -080091import android.view.animation.DecelerateInterpolator;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080092import android.view.inputmethod.InputMethodManager;
Adam Cohen96d30a12013-07-16 18:13:21 -070093import android.widget.Advanceable;
94import android.widget.FrameLayout;
95import android.widget.ImageView;
96import android.widget.TextView;
97import android.widget.Toast;
Patrick Dubroy4ed62782010-08-17 15:11:18 -070098
Daniel Sandler325dc232013-06-05 22:57:57 -040099import com.android.launcher3.DropTarget.DragObject;
Romain Guyedcce092010-03-04 13:03:17 -0800100
Adam Cohenc0dcf592011-06-01 15:30:43 -0700101import java.io.DataInputStream;
102import java.io.DataOutputStream;
Adam Cohen4caf2982013-08-20 18:54:31 -0700103import java.io.File;
Adam Cohen16d7ffc2011-10-05 17:49:14 -0700104import java.io.FileDescriptor;
Adam Cohenc0dcf592011-06-01 15:30:43 -0700105import java.io.FileNotFoundException;
Adam Cohen4caf2982013-08-20 18:54:31 -0700106import java.io.FileOutputStream;
Adam Cohenc0dcf592011-06-01 15:30:43 -0700107import java.io.IOException;
Adam Cohen16d7ffc2011-10-05 17:49:14 -0700108import java.io.PrintWriter;
Adam Cohen4caf2982013-08-20 18:54:31 -0700109import java.text.DateFormat;
Adam Cohenc0dcf592011-06-01 15:30:43 -0700110import java.util.ArrayList;
Winson Chungf0c6ae02012-03-21 16:10:31 -0700111import java.util.Collection;
Adam Cohen4caf2982013-08-20 18:54:31 -0700112import java.util.Date;
Adam Cohenc0dcf592011-06-01 15:30:43 -0700113import java.util.HashMap;
Michael Jurkad7c28052012-04-27 15:43:36 -0700114import java.util.List;
Adam Cohenc0dcf592011-06-01 15:30:43 -0700115
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800116/**
117 * Default launcher application.
118 */
Bjorn Bringertc459e522013-06-07 19:36:01 +0100119public class Launcher extends Activity
Michael Jurka0e260592010-06-30 17:07:39 -0700120 implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks,
Winson Chungcd810732012-06-18 16:45:43 -0700121 View.OnTouchListener {
Joe Onoratoa30ce8e2009-11-11 08:16:49 -0800122 static final String TAG = "Launcher";
Joe Onoratocc67f472010-06-08 10:54:30 -0700123 static final boolean LOGD = false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800124
Daniel Sandlerf061f822013-06-27 13:59:36 -0400125 static final boolean PROFILE_STARTUP = false;
Daniel Sandler843e8602010-06-07 14:59:01 -0400126 static final boolean DEBUG_WIDGETS = false;
Winson Chunga2413752012-04-03 14:22:34 -0700127 static final boolean DEBUG_STRICT_MODE = false;
Daniel Sandlerf061f822013-06-27 13:59:36 -0400128 static final boolean DEBUG_RESUME_TIME = false;
Winson Chungede41292013-09-19 16:27:36 -0700129 static final boolean DEBUG_DUMP_LOG = false;
Romain Guy6fefcf12009-06-11 13:07:43 -0700130
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800131 private static final int REQUEST_CREATE_SHORTCUT = 1;
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700132 private static final int REQUEST_CREATE_APPWIDGET = 5;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800133 private static final int REQUEST_PICK_APPLICATION = 6;
134 private static final int REQUEST_PICK_SHORTCUT = 7;
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700135 private static final int REQUEST_PICK_APPWIDGET = 9;
Mike Clerona0618e42009-10-22 13:55:21 -0700136 private static final int REQUEST_PICK_WALLPAPER = 10;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800137
Michael Jurka8b805b12012-04-18 14:23:14 -0700138 private static final int REQUEST_BIND_APPWIDGET = 11;
139
Mathew Inwood876a8462013-06-14 14:12:41 +0100140 /**
141 * IntentStarter uses request codes starting with this. This must be greater than all activity
142 * request codes used internally.
143 */
144 protected static final int REQUEST_LAST = 100;
145
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800146 static final String EXTRA_SHORTCUT_DUPLICATE = "duplicate";
147
Mike Cleron3a2b3f22009-11-05 17:17:42 -0800148 static final int SCREEN_COUNT = 5;
149 static final int DEFAULT_SCREEN = 2;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800150
Romain Guy98d01652009-06-30 16:21:04 -0700151 private static final String PREFERENCES = "launcher.preferences";
Michael Jurka0a457bf2012-11-19 14:05:05 -0800152 // To turn on these properties, type
153 // adb shell setprop log.tag.PROPERTY_NAME [VERBOSE | SUPPRESS]
154 static final String FORCE_ENABLE_ROTATION_PROPERTY = "launcher_force_rotate";
155 static final String DUMP_STATE_PROPERTY = "launcher_dump_state";
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800156
Winson Chung2672ff92012-05-04 16:22:30 -0700157 // The Intent extra that defines whether to ignore the launch animation
158 static final String INTENT_EXTRA_IGNORE_LAUNCH_ANIMATION =
Daniel Sandler325dc232013-06-05 22:57:57 -0400159 "com.android.launcher3.intent.extra.shortcut.INGORE_LAUNCH_ANIMATION";
Winson Chung2672ff92012-05-04 16:22:30 -0700160
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800161 // Type: int
162 private static final String RUNTIME_STATE_CURRENT_SCREEN = "launcher.current_screen";
Michael Jurka883f55b2010-10-21 15:47:14 -0700163 // Type: int
164 private static final String RUNTIME_STATE = "launcher.state";
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800165 // Type: int
Winson Chung3d503fb2011-07-13 17:25:49 -0700166 private static final String RUNTIME_STATE_PENDING_ADD_CONTAINER = "launcher.add_container";
167 // Type: int
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800168 private static final String RUNTIME_STATE_PENDING_ADD_SCREEN = "launcher.add_screen";
169 // Type: int
Adam Cohenfbba09b2011-07-18 21:43:05 -0700170 private static final String RUNTIME_STATE_PENDING_ADD_CELL_X = "launcher.add_cell_x";
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800171 // Type: int
Adam Cohenfbba09b2011-07-18 21:43:05 -0700172 private static final String RUNTIME_STATE_PENDING_ADD_CELL_Y = "launcher.add_cell_y";
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800173 // Type: boolean
174 private static final String RUNTIME_STATE_PENDING_FOLDER_RENAME = "launcher.rename_folder";
175 // Type: long
176 private static final String RUNTIME_STATE_PENDING_FOLDER_RENAME_ID = "launcher.rename_folder_id";
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700177 // Type: int
178 private static final String RUNTIME_STATE_PENDING_ADD_SPAN_X = "launcher.add_span_x";
179 // Type: int
180 private static final String RUNTIME_STATE_PENDING_ADD_SPAN_Y = "launcher.add_span_y";
181 // Type: parcelable
182 private static final String RUNTIME_STATE_PENDING_ADD_WIDGET_INFO = "launcher.add_widget_info";
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800183
Bjorn Bringerte441bbc2013-06-06 21:54:20 +0100184 private static final String TOOLBAR_ICON_METADATA_NAME = "com.android.launcher.toolbar_icon";
Michael Jurkaae65ee32012-04-30 11:45:54 -0700185 private static final String TOOLBAR_SEARCH_ICON_METADATA_NAME =
Bjorn Bringerte441bbc2013-06-06 21:54:20 +0100186 "com.android.launcher.toolbar_search_icon";
Michael Jurkaae65ee32012-04-30 11:45:54 -0700187 private static final String TOOLBAR_VOICE_SEARCH_ICON_METADATA_NAME =
Bjorn Bringerte441bbc2013-06-06 21:54:20 +0100188 "com.android.launcher.toolbar_voice_search_icon";
Patrick Dubroyceae05d2010-08-30 10:40:53 -0700189
Adam Cohen39a06042013-07-19 14:30:12 -0700190 public static final String SHOW_WEIGHT_WATCHER = "debug.show_mem";
Daniel Sandler6053b802013-08-15 15:44:26 -0700191 public static final boolean SHOW_WEIGHT_WATCHER_DEFAULT = false;
Adam Cohen39a06042013-07-19 14:30:12 -0700192
Patrick Dubroy6b509c12010-08-23 15:08:16 -0700193 /** The different states that Launcher can be in. */
Winson Chung4a2afa32012-07-19 14:53:05 -0700194 private enum State { NONE, WORKSPACE, APPS_CUSTOMIZE, APPS_CUSTOMIZE_SPRING_LOADED };
Michael Jurkac0e8fca2010-10-06 16:41:29 -0700195 private State mState = State.WORKSPACE;
196 private AnimatorSet mStateAnimation;
Patrick Dubroy6b509c12010-08-23 15:08:16 -0700197
Joe Onorato9c1289c2009-08-17 11:03:03 -0400198 static final int APPWIDGET_HOST_ID = 1024;
Winson Chung557d6ed2011-07-08 15:34:52 -0700199 private static final int EXIT_SPRINGLOADED_MODE_SHORT_TIMEOUT = 300;
200 private static final int EXIT_SPRINGLOADED_MODE_LONG_TIMEOUT = 600;
Winson Chungaf40f202013-09-18 18:26:31 -0700201 private static final int SHOW_CLING_DURATION = 250;
202 private static final int DISMISS_CLING_DURATION = 200;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800203
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800204 private static final Object sLock = new Object();
Mike Cleron3a2b3f22009-11-05 17:17:42 -0800205 private static int sScreen = DEFAULT_SCREEN;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800206
Winson Chunga2413752012-04-03 14:22:34 -0700207 // How long to wait before the new-shortcut animation automatically pans the workspace
Winson Chung94d67682013-09-25 16:29:40 -0700208 private static int NEW_APPS_PAGE_MOVE_DELAY = 500;
209 private static int NEW_APPS_ANIMATION_INACTIVE_TIMEOUT_SECONDS = 5;
Winson Chung64359a52013-07-08 17:17:08 -0700210 private static int NEW_APPS_ANIMATION_DELAY = 500;
Winson Chunga2413752012-04-03 14:22:34 -0700211
Joe Onorato2ca0ae72009-11-10 13:14:13 -0800212 private final BroadcastReceiver mCloseSystemDialogsReceiver
213 = new CloseSystemDialogsIntentReceiver();
Jeff Sharkey1e2efc82009-11-06 15:17:59 -0800214 private final ContentObserver mWidgetObserver = new AppWidgetResetObserver();
215
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800216 private LayoutInflater mInflater;
217
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800218 private Workspace mWorkspace;
Craig Mautner360310b2012-10-26 15:13:08 -0700219 private View mLauncherView;
Michael Jurkab737ee62011-11-15 15:57:22 -0800220 private DragLayer mDragLayer;
221 private DragController mDragController;
Adam Cohen39a06042013-07-19 14:30:12 -0700222 private View mWeightWatcher;
Romain Guycbb89e42009-06-08 15:52:54 -0700223
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700224 private AppWidgetManager mAppWidgetManager;
225 private LauncherAppWidgetHost mAppWidgetHost;
Romain Guycbb89e42009-06-08 15:52:54 -0700226
Michael Jurkac9d95c52011-08-29 14:03:34 -0700227 private ItemInfo mPendingAddInfo = new ItemInfo();
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700228 private AppWidgetProviderInfo mPendingAddWidgetInfo;
229
Michael Jurka0280c3b2010-09-17 15:00:07 -0700230 private int[] mTmpAddItemCellCoordinates = new int[2];
231
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800232 private FolderInfo mFolderInfo;
233
Winson Chung3d503fb2011-07-13 17:25:49 -0700234 private Hotseat mHotseat;
Adam Cohenf358a4b2013-07-23 16:47:31 -0700235 private View mOverviewPanel;
236
Michael Jurka838a4ca2011-02-07 13:33:06 -0800237 private View mAllAppsButton;
Winson Chung3d503fb2011-07-13 17:25:49 -0700238
Winson Chungc51db6a2011-10-05 11:44:49 -0700239 private SearchDropTargetBar mSearchDropTargetBar;
Winson Chungf0ea4d32011-06-06 14:27:16 -0700240 private AppsCustomizeTabHost mAppsCustomizeTabHost;
241 private AppsCustomizePagedView mAppsCustomizeContent;
242 private boolean mAutoAdvanceRunning = false;
Cristina Stancu476493b2013-08-07 17:20:14 +0100243 private View mQsbBar;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800244
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800245 private Bundle mSavedState;
Winson Chung4a2afa32012-07-19 14:53:05 -0700246 // We set the state in both onCreate and then onNewIntent in some cases, which causes both
247 // scroll issues (because the workspace may not have been measured yet) and extra work.
248 // Instead, just save the state that we need to restore Launcher to, and commit it in onResume.
249 private State mOnResumeState = State.NONE;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800250
251 private SpannableStringBuilder mDefaultKeySsb = null;
252
Joe Onorato9c1289c2009-08-17 11:03:03 -0400253 private boolean mWorkspaceLoading = true;
254
Joe Onorato34a0e1b2009-12-14 17:44:51 -0800255 private boolean mPaused = true;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800256 private boolean mRestoring;
257 private boolean mWaitingForResult;
Joe Onoratoef2efcf2010-10-27 13:21:00 -0700258 private boolean mOnResumeNeedsLoad;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800259
Michael Jurka1e2f4652013-07-08 18:03:46 -0700260 private ArrayList<Runnable> mBindOnResumeCallbacks = new ArrayList<Runnable>();
Michael Jurka7607c2f2013-04-03 14:33:19 -0700261 private ArrayList<Runnable> mOnResumeCallbacks = new ArrayList<Runnable>();
262
Winson Chung4a2afa32012-07-19 14:53:05 -0700263 // Keep track of whether the user has left launcher
264 private static boolean sPausedFromUserAction = false;
265
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800266 private Bundle mSavedInstanceState;
267
Joe Onorato9c1289c2009-08-17 11:03:03 -0400268 private LauncherModel mModel;
Joe Onorato0589f0f2010-02-08 13:44:00 -0800269 private IconCache mIconCache;
Adam Cohend113e0c2010-11-11 10:48:05 -0800270 private boolean mUserPresent = true;
271 private boolean mVisible = false;
272 private boolean mAttached = false;
Winson Chungfa545132013-09-26 17:45:32 -0700273 private static final boolean DISABLE_CLINGS = false;
Winson Chunge6eabff2013-09-24 11:01:23 -0700274 private static final boolean DISABLE_CUSTOM_CLINGS = true;
Joe Onorato9c1289c2009-08-17 11:03:03 -0400275
Brad Fitzpatrick319226a2010-09-01 13:45:16 -0700276 private static LocaleConfiguration sLocaleConfiguration = null;
277
Brad Fitzpatrick319226a2010-09-01 13:45:16 -0700278 private static HashMap<Long, FolderInfo> sFolders = new HashMap<Long, FolderInfo>();
Romain Guycbb89e42009-06-08 15:52:54 -0700279
Adam Cohen61f560d2013-09-30 15:58:20 -0700280 private View.OnTouchListener mHapticFeedbackTouchListener;
281
Adam Cohended9f8d2010-11-03 13:25:16 -0700282 // Related to the auto-advancing of widgets
283 private final int ADVANCE_MSG = 1;
284 private final int mAdvanceInterval = 20000;
285 private final int mAdvanceStagger = 250;
286 private long mAutoAdvanceSentTime;
287 private long mAutoAdvanceTimeLeft = -1;
288 private HashMap<View, AppWidgetProviderInfo> mWidgetsToAdvance =
289 new HashMap<View, AppWidgetProviderInfo>();
290
Winson Chung400438b2011-01-16 17:53:48 -0800291 // Determines how long to wait after a rotation before restoring the screen orientation to
292 // match the sensor state.
293 private final int mRestoreScreenOrientationDelay = 500;
294
Michael Jurka4ef207b2010-11-29 17:05:45 -0800295 // External icons saved in case of resource changes, orientation, etc.
Winson Chungdff8ebb2011-09-08 17:25:31 -0700296 private static Drawable.ConstantState[] sGlobalSearchIcon = new Drawable.ConstantState[2];
297 private static Drawable.ConstantState[] sVoiceSearchIcon = new Drawable.ConstantState[2];
298 private static Drawable.ConstantState[] sAppMarketIcon = new Drawable.ConstantState[2];
Michael Jurka4ef207b2010-11-29 17:05:45 -0800299
Winson Chungd64a6662013-09-30 11:06:59 -0700300 private Intent mAppMarketIntent = null;
301 private static final boolean DISABLE_MARKET_BUTTON = true;
302
Craig Mautner360310b2012-10-26 15:13:08 -0700303 private Drawable mWorkspaceBackgroundDrawable;
Craig Mautner360310b2012-10-26 15:13:08 -0700304
Adam Cohen1462de32012-07-24 22:34:36 -0700305 private final ArrayList<Integer> mSynchronouslyBoundPages = new ArrayList<Integer>();
306
Adam Cohen16d7ffc2011-10-05 17:49:14 -0700307 static final ArrayList<String> sDumpLogs = new ArrayList<String>();
Adam Cohen4caf2982013-08-20 18:54:31 -0700308 static Date sDateStamp = new Date();
309 static DateFormat sDateFormat =
310 DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT);
311 static long sRunStart = System.currentTimeMillis();
312 static final String CORRUPTION_EMAIL_SENT_KEY = "corruptionEmailSent";
Adam Cohen16d7ffc2011-10-05 17:49:14 -0700313
Winson Chung46353de2012-02-16 14:05:10 -0800314 // We only want to get the SharedPreferences once since it does an FS stat each time we get
315 // it from the context.
316 private SharedPreferences mSharedPrefs;
317
Adam Cohene25af792013-06-06 23:08:25 -0700318 private static ArrayList<ComponentName> mIntentsOnWorkspaceFromUpgradePath = null;
319
Winson Chungf0c6ae02012-03-21 16:10:31 -0700320 // Holds the page that we need to animate to, and the icon views that we need to animate up
321 // when we scroll to that page on resume.
Adam Cohen268c4752012-06-06 17:47:33 -0700322 private ImageView mFolderIconImageView;
323 private Bitmap mFolderIconBitmap;
324 private Canvas mFolderIconCanvas;
325 private Rect mRectForFolderAnimation = new Rect();
Adam Cohen2801caf2011-05-13 20:57:39 -0700326
Michael Jurkaddd62e92011-02-16 17:49:14 -0800327 private BubbleTextView mWaitingForResume;
328
Michael Jurka7267fa52013-09-26 15:29:57 -0700329 protected TransparentBars mTransparentBars;
330
Michael Jurka22143132012-10-04 17:42:38 +0200331 private HideFromAccessibilityHelper mHideFromAccessibilityHelper
332 = new HideFromAccessibilityHelper();
333
Michael Jurkac1f5d262011-09-30 19:32:27 -0700334 private Runnable mBuildLayersRunnable = new Runnable() {
335 public void run() {
Michael Jurka9d906c72011-10-14 06:25:36 -0700336 if (mWorkspace != null) {
337 mWorkspace.buildPageHardwareLayers();
338 }
Michael Jurkac1f5d262011-09-30 19:32:27 -0700339 }
340 };
341
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800342 private static ArrayList<PendingAddArguments> sPendingAddList
343 = new ArrayList<PendingAddArguments>();
344
Michael Jurka7267fa52013-09-26 15:29:57 -0700345 public static boolean sForceEnableRotation = isPropertyEnabled(FORCE_ENABLE_ROTATION_PROPERTY);
Michael Jurka0a457bf2012-11-19 14:05:05 -0800346
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800347 private static class PendingAddArguments {
348 int requestCode;
349 Intent intent;
Winson Chung3d503fb2011-07-13 17:25:49 -0700350 long container;
Adam Cohendcd297f2013-06-18 13:13:40 -0700351 long screenId;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800352 int cellX;
353 int cellY;
354 }
355
Daniel Sandlerff02d492013-08-05 02:12:05 -0400356 private Stats mStats;
357
Michael Jurka0a457bf2012-11-19 14:05:05 -0800358 private static boolean isPropertyEnabled(String propertyName) {
359 return Log.isLoggable(propertyName, Log.VERBOSE);
Michael Jurka9bc8eba2012-05-21 20:36:44 -0700360 }
361
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800362 @Override
363 protected void onCreate(Bundle savedInstanceState) {
Winson Chunga2413752012-04-03 14:22:34 -0700364 if (DEBUG_STRICT_MODE) {
365 StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
366 .detectDiskReads()
367 .detectDiskWrites()
368 .detectNetwork() // or .detectAll() for all detectable problems
369 .penaltyLog()
370 .build());
371 StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
372 .detectLeakedSqlLiteObjects()
373 .detectLeakedClosableObjects()
374 .penaltyLog()
375 .penaltyDeath()
376 .build());
377 }
378
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800379 super.onCreate(savedInstanceState);
Daniel Sandlere060b0b2013-06-27 21:47:55 -0400380
Daniel Sandlere060b0b2013-06-27 21:47:55 -0400381 LauncherAppState.setApplicationContext(getApplicationContext());
Daniel Sandlercc8befa2013-06-11 14:45:48 -0400382 LauncherAppState app = LauncherAppState.getInstance();
Winson Chung5f8afe62013-08-12 16:19:28 -0700383
384 // Determine the dynamic grid properties
385 Point smallestSize = new Point();
386 Point largestSize = new Point();
387 Point realSize = new Point();
388 Display display = getWindowManager().getDefaultDisplay();
389 display.getCurrentSizeRange(smallestSize, largestSize);
390 display.getRealSize(realSize);
Winson Chung892c74d2013-08-22 16:15:50 -0700391 DisplayMetrics dm = new DisplayMetrics();
392 display.getMetrics(dm);
Winson Chung5f8afe62013-08-12 16:19:28 -0700393 // Lazy-initialize the dynamic grid
394 DeviceProfile grid = app.initDynamicGrid(this,
395 Math.min(smallestSize.x, smallestSize.y),
396 Math.min(largestSize.x, largestSize.y),
Winson Chung892c74d2013-08-22 16:15:50 -0700397 realSize.x, realSize.y,
398 dm.widthPixels, dm.heightPixels);
Winson Chung5f8afe62013-08-12 16:19:28 -0700399
400 // the LauncherApplication should call this, but in case of Instrumentation it might not be present yet
Daniel Sandlercc8befa2013-06-11 14:45:48 -0400401 mSharedPrefs = getSharedPreferences(LauncherAppState.getSharedPreferencesKey(),
Winson Chungf0c6ae02012-03-21 16:10:31 -0700402 Context.MODE_PRIVATE);
Joe Onorato0589f0f2010-02-08 13:44:00 -0800403 mModel = app.setLauncher(this);
404 mIconCache = app.getIconCache();
Joe Onorato41a12d22009-10-31 18:30:00 -0400405 mDragController = new DragController(this);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800406 mInflater = getLayoutInflater();
Romain Guycbb89e42009-06-08 15:52:54 -0700407
Daniel Sandlerff02d492013-08-05 02:12:05 -0400408 mStats = new Stats(this);
409
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700410 mAppWidgetManager = AppWidgetManager.getInstance(this);
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700411 mAppWidgetHost = new LauncherAppWidgetHost(this, APPWIDGET_HOST_ID);
412 mAppWidgetHost.startListening();
Romain Guycbb89e42009-06-08 15:52:54 -0700413
Winson Chungb8b2a5a2012-07-12 17:55:31 -0700414 // If we are getting an onCreate, we can actually preempt onResume and unset mPaused here,
415 // this also ensures that any synchronous binding below doesn't re-trigger another
416 // LauncherModel load.
417 mPaused = false;
418
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800419 if (PROFILE_STARTUP) {
Christian Mehlmauer0fbe7bc2010-08-02 20:27:46 +0200420 android.os.Debug.startMethodTracing(
421 Environment.getExternalStorageDirectory() + "/launcher");
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800422 }
423
424 checkForLocaleChange();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800425 setContentView(R.layout.launcher);
Michael Jurka7267fa52013-09-26 15:29:57 -0700426
427 mTransparentBars = new TransparentBars(findViewById(R.id.launcher));
428 mTransparentBars.requestTransparentBars(true);
429
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800430 setupViews();
Cristina Stancu476493b2013-08-07 17:20:14 +0100431 grid.layout(this);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800432
Jeff Sharkey1e2efc82009-11-06 15:17:59 -0800433 registerContentObservers();
434
Joe Onorato7c312c12009-08-13 21:36:53 -0700435 lockAllApps();
Joe Onorato7404ee42009-07-31 11:54:44 -0700436
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800437 mSavedState = savedInstanceState;
438 restoreState(mSavedState);
439
Winson Chunga12a2502010-12-20 14:41:35 -0800440 // Update customization drawer _after_ restoring the states
Winson Chung785d2eb2011-04-14 16:08:02 -0700441 if (mAppsCustomizeContent != null) {
Michael Jurkac402cd92013-05-20 15:49:32 +0200442 mAppsCustomizeContent.onPackagesUpdated(
443 LauncherModel.getSortedWidgetsAndShortcuts(this));
Winson Chung785d2eb2011-04-14 16:08:02 -0700444 }
Winson Chunga12a2502010-12-20 14:41:35 -0800445
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800446 if (PROFILE_STARTUP) {
447 android.os.Debug.stopMethodTracing();
448 }
449
450 if (!mRestoring) {
Winson Chung4a2afa32012-07-19 14:53:05 -0700451 if (sPausedFromUserAction) {
452 // If the user leaves launcher, then we should just load items asynchronously when
453 // they return.
454 mModel.startLoader(true, -1);
455 } else {
456 // We only load the page synchronously if the user rotates (or triggers a
457 // configuration change) while launcher is in the foreground
458 mModel.startLoader(true, mWorkspace.getCurrentPage());
459 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800460 }
461
462 // For handling default keys
463 mDefaultKeySsb = new SpannableStringBuilder();
464 Selection.setSelection(mDefaultKeySsb, 0);
Joe Onorato34a0e1b2009-12-14 17:44:51 -0800465
466 IntentFilter filter = new IntentFilter(Intent.ACTION_CLOSE_SYSTEM_DIALOGS);
467 registerReceiver(mCloseSystemDialogsReceiver, filter);
Michael Jurka4ef207b2010-11-29 17:05:45 -0800468
Adam Cohenf9426d52012-06-04 17:26:21 -0700469 updateGlobalIcons();
470
471 // On large interfaces, we want the screen to auto-rotate based on the current orientation
472 unlockScreenOrientation(true);
Winson Chungaf40f202013-09-18 18:26:31 -0700473
474 showFirstRunCling();
Adam Cohenf9426d52012-06-04 17:26:21 -0700475 }
476
Winson Chung4a2afa32012-07-19 14:53:05 -0700477 protected void onUserLeaveHint() {
478 super.onUserLeaveHint();
479 sPausedFromUserAction = true;
480 }
481
Winson Chung98ca0f72013-07-29 12:58:51 -0700482 /** To be overriden by subclasses to hint to Launcher that we have custom content */
483 protected boolean hasCustomContentToLeft() {
484 return false;
485 }
486
Dave Hawkeya8881582013-09-17 15:55:33 -0600487 /**
488 * To be overridden by subclasses to create the custom content and call
489 * {@link #addToCustomContentPage}. This will only be invoked if
490 * {@link #hasCustomContentToLeft()} is {@code true}.
491 */
492 protected void addCustomContentToLeft() {
493 }
494
495 /**
496 * Invoked by subclasses to signal a change to the {@link #addCustomContentToLeft} value to
497 * ensure the custom content page is added or removed if necessary.
498 */
499 protected void invalidateHasCustomContentToLeft() {
Dave Hawkey3a733a72013-09-30 11:52:21 -0600500 if (mWorkspace == null || mWorkspace.getScreenOrder().isEmpty()) {
Dave Hawkeya8881582013-09-17 15:55:33 -0600501 // Not bound yet, wait for bindScreens to be called.
502 return;
503 }
504
505 if (!mWorkspace.hasCustomContent() && hasCustomContentToLeft()) {
506 // Create the custom content page and call the subclass to populate it.
507 mWorkspace.createCustomContentPage();
508 addCustomContentToLeft();
509 } else if (mWorkspace.hasCustomContent() && !hasCustomContentToLeft()) {
510 mWorkspace.removeCustomContentPage();
511 }
512 }
513
Adam Cohenf9426d52012-06-04 17:26:21 -0700514 private void updateGlobalIcons() {
Winson Chungc51db6a2011-10-05 11:44:49 -0700515 boolean searchVisible = false;
516 boolean voiceVisible = false;
Michael Jurka4ef207b2010-11-29 17:05:45 -0800517 // If we have a saved version of these external icons, we load them up immediately
Winson Chungdff8ebb2011-09-08 17:25:31 -0700518 int coi = getCurrentOrientationIndexForGlobalIcons();
519 if (sGlobalSearchIcon[coi] == null || sVoiceSearchIcon[coi] == null ||
520 sAppMarketIcon[coi] == null) {
Winson Chungd64a6662013-09-30 11:06:59 -0700521 if (!DISABLE_MARKET_BUTTON) {
522 updateAppMarketIcon();
523 }
Winson Chungc51db6a2011-10-05 11:44:49 -0700524 searchVisible = updateGlobalSearchIcon();
525 voiceVisible = updateVoiceSearchIcon(searchVisible);
Winson Chungf0ea4d32011-06-06 14:27:16 -0700526 }
Winson Chungdff8ebb2011-09-08 17:25:31 -0700527 if (sGlobalSearchIcon[coi] != null) {
528 updateGlobalSearchIcon(sGlobalSearchIcon[coi]);
Winson Chungc51db6a2011-10-05 11:44:49 -0700529 searchVisible = true;
Winson Chungf0ea4d32011-06-06 14:27:16 -0700530 }
Winson Chungdff8ebb2011-09-08 17:25:31 -0700531 if (sVoiceSearchIcon[coi] != null) {
532 updateVoiceSearchIcon(sVoiceSearchIcon[coi]);
Winson Chungc51db6a2011-10-05 11:44:49 -0700533 voiceVisible = true;
Winson Chungf0ea4d32011-06-06 14:27:16 -0700534 }
Winson Chungd64a6662013-09-30 11:06:59 -0700535 if (!DISABLE_MARKET_BUTTON && sAppMarketIcon[coi] != null) {
Winson Chungdff8ebb2011-09-08 17:25:31 -0700536 updateAppMarketIcon(sAppMarketIcon[coi]);
Michael Jurka4ef207b2010-11-29 17:05:45 -0800537 }
Winson Chungadf0c182012-08-23 14:59:07 -0700538 if (mSearchDropTargetBar != null) {
539 mSearchDropTargetBar.onSearchPackagesChanged(searchVisible, voiceVisible);
540 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800541 }
Romain Guycbb89e42009-06-08 15:52:54 -0700542
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800543 private void checkForLocaleChange() {
Brad Fitzpatrick319226a2010-09-01 13:45:16 -0700544 if (sLocaleConfiguration == null) {
545 new AsyncTask<Void, Void, LocaleConfiguration>() {
546 @Override
547 protected LocaleConfiguration doInBackground(Void... unused) {
548 LocaleConfiguration localeConfiguration = new LocaleConfiguration();
549 readConfiguration(Launcher.this, localeConfiguration);
550 return localeConfiguration;
551 }
552
553 @Override
554 protected void onPostExecute(LocaleConfiguration result) {
555 sLocaleConfiguration = result;
556 checkForLocaleChange(); // recursive, but now with a locale configuration
557 }
558 }.execute();
559 return;
560 }
Jason Samsfd22dac2009-09-20 17:24:16 -0700561
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800562 final Configuration configuration = getResources().getConfiguration();
563
Brad Fitzpatrick319226a2010-09-01 13:45:16 -0700564 final String previousLocale = sLocaleConfiguration.locale;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800565 final String locale = configuration.locale.toString();
566
Brad Fitzpatrick319226a2010-09-01 13:45:16 -0700567 final int previousMcc = sLocaleConfiguration.mcc;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800568 final int mcc = configuration.mcc;
569
Brad Fitzpatrick319226a2010-09-01 13:45:16 -0700570 final int previousMnc = sLocaleConfiguration.mnc;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800571 final int mnc = configuration.mnc;
572
Romain Guy84f296c2009-11-04 15:00:44 -0800573 boolean localeChanged = !locale.equals(previousLocale) || mcc != previousMcc || mnc != previousMnc;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800574
Romain Guy84f296c2009-11-04 15:00:44 -0800575 if (localeChanged) {
Brad Fitzpatrick319226a2010-09-01 13:45:16 -0700576 sLocaleConfiguration.locale = locale;
577 sLocaleConfiguration.mcc = mcc;
578 sLocaleConfiguration.mnc = mnc;
Romain Guy98d01652009-06-30 16:21:04 -0700579
Joe Onorato0589f0f2010-02-08 13:44:00 -0800580 mIconCache.flush();
Brad Fitzpatrick319226a2010-09-01 13:45:16 -0700581
582 final LocaleConfiguration localeConfiguration = sLocaleConfiguration;
583 new Thread("WriteLocaleConfiguration") {
Gilles Debunnedd6c9922010-10-25 11:23:41 -0700584 @Override
Brad Fitzpatrick319226a2010-09-01 13:45:16 -0700585 public void run() {
586 writeConfiguration(Launcher.this, localeConfiguration);
587 }
588 }.start();
Romain Guy98d01652009-06-30 16:21:04 -0700589 }
590 }
591
592 private static class LocaleConfiguration {
593 public String locale;
594 public int mcc = -1;
595 public int mnc = -1;
596 }
Jason Samsfd22dac2009-09-20 17:24:16 -0700597
Romain Guy98d01652009-06-30 16:21:04 -0700598 private static void readConfiguration(Context context, LocaleConfiguration configuration) {
599 DataInputStream in = null;
600 try {
601 in = new DataInputStream(context.openFileInput(PREFERENCES));
602 configuration.locale = in.readUTF();
603 configuration.mcc = in.readInt();
604 configuration.mnc = in.readInt();
605 } catch (FileNotFoundException e) {
606 // Ignore
607 } catch (IOException e) {
608 // Ignore
609 } finally {
610 if (in != null) {
611 try {
612 in.close();
613 } catch (IOException e) {
614 // Ignore
615 }
616 }
617 }
618 }
619
620 private static void writeConfiguration(Context context, LocaleConfiguration configuration) {
621 DataOutputStream out = null;
622 try {
623 out = new DataOutputStream(context.openFileOutput(PREFERENCES, MODE_PRIVATE));
624 out.writeUTF(configuration.locale);
625 out.writeInt(configuration.mcc);
626 out.writeInt(configuration.mnc);
627 out.flush();
628 } catch (FileNotFoundException e) {
629 // Ignore
630 } catch (IOException e) {
631 //noinspection ResultOfMethodCallIgnored
632 context.getFileStreamPath(PREFERENCES).delete();
633 } finally {
634 if (out != null) {
635 try {
636 out.close();
637 } catch (IOException e) {
638 // Ignore
639 }
640 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800641 }
642 }
643
Anton Hanssona2f665f2013-09-26 12:18:32 +0100644 public Stats getStats() {
645 return mStats;
646 }
647
Bjorn Bringertc459e522013-06-07 19:36:01 +0100648 public LayoutInflater getInflater() {
649 return mInflater;
650 }
651
Adam Cohen716b51e2011-06-30 12:09:54 -0700652 public DragLayer getDragLayer() {
653 return mDragLayer;
654 }
655
Winson Chung36a62fe2012-05-06 18:04:42 -0700656 boolean isDraggingEnabled() {
657 // We prevent dragging when we are loading the workspace as it is possible to pick up a view
658 // that is subsequently removed from the workspace in startBinding().
659 return !mModel.isLoadingWorkspace();
660 }
661
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800662 static int getScreen() {
663 synchronized (sLock) {
664 return sScreen;
665 }
666 }
667
668 static void setScreen(int screen) {
669 synchronized (sLock) {
670 sScreen = screen;
671 }
672 }
673
Winson Chung557d6ed2011-07-08 15:34:52 -0700674 /**
675 * Returns whether we should delay spring loaded mode -- for shortcuts and widgets that have
676 * a configuration step, this allows the proper animations to run after other transitions.
677 */
678 private boolean completeAdd(PendingAddArguments args) {
Winson Chungb8472bb2011-08-05 13:49:21 -0700679 boolean result = false;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800680 switch (args.requestCode) {
681 case REQUEST_PICK_APPLICATION:
Adam Cohendcd297f2013-06-18 13:13:40 -0700682 completeAddApplication(args.intent, args.container, args.screenId, args.cellX,
Winson Chung3d503fb2011-07-13 17:25:49 -0700683 args.cellY);
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800684 break;
685 case REQUEST_PICK_SHORTCUT:
686 processShortcut(args.intent);
687 break;
688 case REQUEST_CREATE_SHORTCUT:
Adam Cohendcd297f2013-06-18 13:13:40 -0700689 completeAddShortcut(args.intent, args.container, args.screenId, args.cellX,
Winson Chung3d503fb2011-07-13 17:25:49 -0700690 args.cellY);
Winson Chungb8472bb2011-08-05 13:49:21 -0700691 result = true;
692 break;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800693 case REQUEST_CREATE_APPWIDGET:
694 int appWidgetId = args.intent.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1);
Adam Cohendcd297f2013-06-18 13:13:40 -0700695 completeAddAppWidget(appWidgetId, args.container, args.screenId, null, null);
Winson Chungb8472bb2011-08-05 13:49:21 -0700696 result = true;
697 break;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800698 }
Michael Jurka27614d22012-04-02 06:40:22 -0700699 // Before adding this resetAddInfo(), after a shortcut was added to a workspace screen,
700 // if you turned the screen off and then back while in All Apps, Launcher would not
701 // return to the workspace. Clearing mAddInfo.container here fixes this issue
702 resetAddInfo();
Winson Chungb8472bb2011-08-05 13:49:21 -0700703 return result;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800704 }
705
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800706 @Override
Michael Jurka8b805b12012-04-18 14:23:14 -0700707 protected void onActivityResult(
708 final int requestCode, final int resultCode, final Intent data) {
Winson Chunge341d302013-08-16 14:31:00 -0700709 // Reset the startActivity waiting flag
710 mWaitingForResult = false;
711
Michael Jurka8b805b12012-04-18 14:23:14 -0700712 if (requestCode == REQUEST_BIND_APPWIDGET) {
713 int appWidgetId = data != null ?
714 data.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1) : -1;
715 if (resultCode == RESULT_CANCELED) {
716 completeTwoStageWidgetDrop(RESULT_CANCELED, appWidgetId);
717 } else if (resultCode == RESULT_OK) {
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700718 addAppWidgetImpl(appWidgetId, mPendingAddInfo, null, mPendingAddWidgetInfo);
Michael Jurka8b805b12012-04-18 14:23:14 -0700719 }
720 return;
Michael Jurka336fd4f2013-09-12 00:05:02 +0200721 } else if (requestCode == REQUEST_PICK_WALLPAPER) {
722 if (resultCode == RESULT_OK && mWorkspace.isInOverviewMode()) {
723 mWorkspace.exitOverviewMode(false);
724 }
725 return;
Michael Jurka8b805b12012-04-18 14:23:14 -0700726 }
Michael Jurka336fd4f2013-09-12 00:05:02 +0200727
Winson Chung557d6ed2011-07-08 15:34:52 -0700728 boolean delayExitSpringLoadedMode = false;
Adam Cohened66b2b2012-01-23 17:28:51 -0800729 boolean isWidgetDrop = (requestCode == REQUEST_PICK_APPWIDGET ||
730 requestCode == REQUEST_CREATE_APPWIDGET);
Romain Guyaad5ef42009-06-10 02:48:37 -0700731
Adam Cohened66b2b2012-01-23 17:28:51 -0800732 // We have special handling for widgets
733 if (isWidgetDrop) {
734 int appWidgetId = data != null ?
735 data.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1) : -1;
Winson Chung5aaab772012-04-27 15:24:02 -0700736 if (appWidgetId < 0) {
737 Log.e(TAG, "Error: appWidgetId (EXTRA_APPWIDGET_ID) was not returned from the \\" +
738 "widget configuration activity.");
739 completeTwoStageWidgetDrop(RESULT_CANCELED, appWidgetId);
740 } else {
741 completeTwoStageWidgetDrop(resultCode, appWidgetId);
742 }
Adam Cohened66b2b2012-01-23 17:28:51 -0800743 return;
744 }
745
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800746 // The pattern used here is that a user PICKs a specific application,
747 // which, depending on the target, might need to CREATE the actual target.
Romain Guycbb89e42009-06-08 15:52:54 -0700748
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800749 // For example, the user would PICK_SHORTCUT for "Music playlist", and we
750 // launch over to the Music app to actually CREATE_SHORTCUT.
Winson Chungc7da5552011-08-10 15:28:45 -0700751 if (resultCode == RESULT_OK && mPendingAddInfo.container != ItemInfo.NO_ID) {
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800752 final PendingAddArguments args = new PendingAddArguments();
753 args.requestCode = requestCode;
754 args.intent = data;
Winson Chung3d503fb2011-07-13 17:25:49 -0700755 args.container = mPendingAddInfo.container;
Adam Cohendcd297f2013-06-18 13:13:40 -0700756 args.screenId = mPendingAddInfo.screenId;
Winson Chung3d503fb2011-07-13 17:25:49 -0700757 args.cellX = mPendingAddInfo.cellX;
758 args.cellY = mPendingAddInfo.cellY;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800759 if (isWorkspaceLocked()) {
760 sPendingAddList.add(args);
761 } else {
Winson Chung557d6ed2011-07-08 15:34:52 -0700762 delayExitSpringLoadedMode = completeAdd(args);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800763 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800764 }
Adam Cohened66b2b2012-01-23 17:28:51 -0800765 mDragLayer.clearAnimatedView();
Winson Chung557d6ed2011-07-08 15:34:52 -0700766 // Exit spring loaded mode if necessary after cancelling the configuration of a widget
Adam Cohened66b2b2012-01-23 17:28:51 -0800767 exitSpringLoadedDragModeDelayed((resultCode != RESULT_CANCELED), delayExitSpringLoadedMode,
768 null);
769 }
770
771 private void completeTwoStageWidgetDrop(final int resultCode, final int appWidgetId) {
Michael Jurka8b805b12012-04-18 14:23:14 -0700772 CellLayout cellLayout =
Adam Cohendcd297f2013-06-18 13:13:40 -0700773 (CellLayout) mWorkspace.getScreenWithId(mPendingAddInfo.screenId);
Adam Cohened66b2b2012-01-23 17:28:51 -0800774 Runnable onCompleteRunnable = null;
775 int animationType = 0;
776
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700777 AppWidgetHostView boundWidget = null;
Adam Cohened66b2b2012-01-23 17:28:51 -0800778 if (resultCode == RESULT_OK) {
779 animationType = Workspace.COMPLETE_TWO_STAGE_WIDGET_DROP_ANIMATION;
780 final AppWidgetHostView layout = mAppWidgetHost.createView(this, appWidgetId,
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700781 mPendingAddWidgetInfo);
782 boundWidget = layout;
Adam Cohened66b2b2012-01-23 17:28:51 -0800783 onCompleteRunnable = new Runnable() {
784 @Override
785 public void run() {
786 completeAddAppWidget(appWidgetId, mPendingAddInfo.container,
Adam Cohendcd297f2013-06-18 13:13:40 -0700787 mPendingAddInfo.screenId, layout, null);
Adam Cohened66b2b2012-01-23 17:28:51 -0800788 exitSpringLoadedDragModeDelayed((resultCode != RESULT_CANCELED), false,
789 null);
790 }
791 };
792 } else if (resultCode == RESULT_CANCELED) {
793 animationType = Workspace.CANCEL_TWO_STAGE_WIDGET_DROP_ANIMATION;
794 onCompleteRunnable = new Runnable() {
795 @Override
796 public void run() {
797 exitSpringLoadedDragModeDelayed((resultCode != RESULT_CANCELED), false,
798 null);
799 }
800 };
801 }
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700802 if (mDragLayer.getAnimatedView() != null) {
803 mWorkspace.animateWidgetDrop(mPendingAddInfo, cellLayout,
804 (DragView) mDragLayer.getAnimatedView(), onCompleteRunnable,
805 animationType, boundWidget, true);
806 } else {
807 // The animated view may be null in the case of a rotation during widget configuration
808 onCompleteRunnable.run();
809 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800810 }
811
812 @Override
Michael Jurkacd496d72013-04-11 11:32:45 -0700813 protected void onStop() {
814 super.onStop();
815 FirstFrameAnimatorHelper.setIsVisible(false);
816 }
817
818 @Override
819 protected void onStart() {
820 super.onStart();
821 FirstFrameAnimatorHelper.setIsVisible(true);
822 }
823
824 @Override
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800825 protected void onResume() {
Michael Jurka447bf842013-05-15 14:52:15 +0200826 long startTime = 0;
827 if (DEBUG_RESUME_TIME) {
828 startTime = System.currentTimeMillis();
Daniel Sandler924b9932013-06-12 00:38:25 -0400829 Log.v(TAG, "Launcher.onResume()");
Michael Jurka447bf842013-05-15 14:52:15 +0200830 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800831 super.onResume();
Winson Chungf0c6ae02012-03-21 16:10:31 -0700832
Winson Chung4a2afa32012-07-19 14:53:05 -0700833 // Restore the previous launcher state
834 if (mOnResumeState == State.WORKSPACE) {
835 showWorkspace(false);
836 } else if (mOnResumeState == State.APPS_CUSTOMIZE) {
Winson Chungc58497e2013-09-03 17:48:37 -0700837 showAllApps(false, AppsCustomizePagedView.ContentType.Applications);
Winson Chung4a2afa32012-07-19 14:53:05 -0700838 }
839 mOnResumeState = State.NONE;
840
Craig Mautner360310b2012-10-26 15:13:08 -0700841 // Background was set to gradient in onPause(), restore to black if in all apps.
842 setWorkspaceBackground(mState == State.WORKSPACE);
843
Joe Onorato34a0e1b2009-12-14 17:44:51 -0800844 mPaused = false;
Winson Chung4a2afa32012-07-19 14:53:05 -0700845 sPausedFromUserAction = false;
Joe Onoratoef2efcf2010-10-27 13:21:00 -0700846 if (mRestoring || mOnResumeNeedsLoad) {
Joe Onorato9c1289c2009-08-17 11:03:03 -0400847 mWorkspaceLoading = true;
Winson Chungb8b2a5a2012-07-12 17:55:31 -0700848 mModel.startLoader(true, -1);
Joe Onorato9c1289c2009-08-17 11:03:03 -0400849 mRestoring = false;
Joe Onoratoef2efcf2010-10-27 13:21:00 -0700850 mOnResumeNeedsLoad = false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800851 }
Michael Jurka1e2f4652013-07-08 18:03:46 -0700852 if (mBindOnResumeCallbacks.size() > 0) {
Michael Jurkac402cd92013-05-20 15:49:32 +0200853 // We might have postponed some bind calls until onResume (see waitUntilResume) --
854 // execute them here
855 long startTimeCallbacks = 0;
856 if (DEBUG_RESUME_TIME) {
857 startTimeCallbacks = System.currentTimeMillis();
858 }
859
860 if (mAppsCustomizeContent != null) {
861 mAppsCustomizeContent.setBulkBind(true);
862 }
Michael Jurka1e2f4652013-07-08 18:03:46 -0700863 for (int i = 0; i < mBindOnResumeCallbacks.size(); i++) {
864 mBindOnResumeCallbacks.get(i).run();
Michael Jurkac402cd92013-05-20 15:49:32 +0200865 }
866 if (mAppsCustomizeContent != null) {
867 mAppsCustomizeContent.setBulkBind(false);
868 }
Michael Jurka1e2f4652013-07-08 18:03:46 -0700869 mBindOnResumeCallbacks.clear();
Michael Jurkac402cd92013-05-20 15:49:32 +0200870 if (DEBUG_RESUME_TIME) {
871 Log.d(TAG, "Time spent processing callbacks in onResume: " +
872 (System.currentTimeMillis() - startTimeCallbacks));
873 }
Michael Jurka447bf842013-05-15 14:52:15 +0200874 }
Michael Jurka54554252013-08-01 12:52:23 +0200875 if (mOnResumeCallbacks.size() > 0) {
876 for (int i = 0; i < mOnResumeCallbacks.size(); i++) {
877 mOnResumeCallbacks.get(i).run();
878 }
879 mOnResumeCallbacks.clear();
880 }
Winson Chunge4e50662012-01-23 14:45:13 -0800881
882 // Reset the pressed state of icons that were locked in the press state while activities
883 // were launching
Michael Jurkaddd62e92011-02-16 17:49:14 -0800884 if (mWaitingForResume != null) {
Winson Chunge4e50662012-01-23 14:45:13 -0800885 // Resets the previous workspace icon press state
Michael Jurkaddd62e92011-02-16 17:49:14 -0800886 mWaitingForResume.setStayPressed(false);
887 }
Winson Chunge4e50662012-01-23 14:45:13 -0800888 if (mAppsCustomizeContent != null) {
889 // Resets the previous all apps icon press state
890 mAppsCustomizeContent.resetDrawableState();
891 }
Winson Chung780fe592013-09-26 14:48:44 -0700892 // Reset AllApps to its initial state
893 if (mAppsCustomizeTabHost != null) {
894 mAppsCustomizeTabHost.reset();
895 }
Adam Cohen06dff352012-06-01 17:17:08 -0700896 // It is possible that widgets can receive updates while launcher is not in the foreground.
897 // Consequently, the widgets will be inflated in the orientation of the foreground activity
898 // (framework issue). On resuming, we ensure that any widgets are inflated for the current
899 // orientation.
Adam Cohen3d509322012-06-06 14:10:04 -0700900 getWorkspace().reinflateWidgetsIfNecessary();
Adam Cohenf9426d52012-06-04 17:26:21 -0700901
Winson Chung780fe592013-09-26 14:48:44 -0700902 // Process any items that were added while Launcher was away.
903 InstallShortcutReceiver.disableAndFlushInstallQueue(this);
904
Winson Chung5841efa2013-09-30 18:06:44 -0700905 // Update the voice search button proxy
906 updateVoiceButtonProxyVisible(false);
907
Adam Cohenf9426d52012-06-04 17:26:21 -0700908 // Again, as with the above scenario, it's possible that one or more of the global icons
909 // were updated in the wrong orientation.
910 updateGlobalIcons();
Michael Jurka447bf842013-05-15 14:52:15 +0200911 if (DEBUG_RESUME_TIME) {
912 Log.d(TAG, "Time spent in onResume: " + (System.currentTimeMillis() - startTime));
913 }
Adam Cohenedaaa302013-10-01 17:33:27 -0700914 mWorkspace.updateInteractionForState();
Adam Cohen06dff352012-06-01 17:17:08 -0700915 }
916
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800917 @Override
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700918 protected void onPause() {
Winson Chung997a9232013-07-24 15:33:46 -0700919 // Ensure that items added to Launcher are queued until Launcher returns
920 InstallShortcutReceiver.enableInstallQueue();
921
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700922 super.onPause();
Joe Onoratoef2efcf2010-10-27 13:21:00 -0700923 mPaused = true;
Joe Onorato24b6fd82009-11-12 13:47:09 -0800924 mDragController.cancelDrag();
Winson Chunga2413752012-04-03 14:22:34 -0700925 mDragController.resetLastGestureUpTime();
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700926 }
Romain Guycbb89e42009-06-08 15:52:54 -0700927
Adam Cohen66a01fd2013-06-11 12:48:00 -0700928 protected void onFinishBindingItems() {
Adam Cohen82398362013-09-29 12:57:34 -0700929 if (mWorkspace != null && hasCustomContentToLeft() && mWorkspace.hasCustomContent()) {
Dave Hawkeya8881582013-09-17 15:55:33 -0600930 addCustomContentToLeft();
931 }
Adam Cohen66a01fd2013-06-11 12:48:00 -0700932 }
933
Adam Cohenbffe7452013-07-22 18:21:45 -0700934 QSBScroller mQsbScroller = new QSBScroller() {
935 int scrollY = 0;
936
937 @Override
938 public void setScrollY(int scroll) {
939 scrollY = scroll;
940
941 if (mWorkspace.isOnOrMovingToCustomContent()) {
942 mSearchDropTargetBar.setTranslationY(- scrollY);
Mark Brophyd7dc6812013-09-20 17:27:32 +0100943 getQsbBar().setTranslationY(-scrollY);
Adam Cohenbffe7452013-07-22 18:21:45 -0700944 }
945 }
946 };
947
948 public void resetQSBScroll() {
949 mSearchDropTargetBar.animate().translationY(0).start();
Mark Brophyd7dc6812013-09-20 17:27:32 +0100950 getQsbBar().animate().translationY(0).start();
Adam Cohenbffe7452013-07-22 18:21:45 -0700951 }
952
953 public interface CustomContentCallbacks {
954 // Custom content is completely shown
955 public void onShow();
956
957 // Custom content is completely hidden
958 public void onHide();
Adam Cohenc36fa5c2013-08-29 11:54:42 -0700959
960 // Custom content scroll progress changed. From 0 (not showing) to 1 (fully showing).
961 public void onScrollProgressChanged(float progress);
Adam Cohenbffe7452013-07-22 18:21:45 -0700962 }
963
Adam Cohen30bacb22013-08-29 14:25:25 -0700964 protected void startSettings() {
965 }
966
Adam Cohenbffe7452013-07-22 18:21:45 -0700967 public interface QSBScroller {
968 public void setScrollY(int scrollY);
969 }
970
Adam Cohen66a01fd2013-06-11 12:48:00 -0700971 // Add a fullscreen unpadded view to the workspace to the left all other screens.
Winson Chung98ca0f72013-07-29 12:58:51 -0700972 public QSBScroller addToCustomContentPage(View customContent) {
973 return addToCustomContentPage(customContent, null);
Adam Cohenbffe7452013-07-22 18:21:45 -0700974 }
975
Winson Chung98ca0f72013-07-29 12:58:51 -0700976 public QSBScroller addToCustomContentPage(View customContent,
Adam Cohenbffe7452013-07-22 18:21:45 -0700977 CustomContentCallbacks callbacks) {
Winson Chung98ca0f72013-07-29 12:58:51 -0700978 mWorkspace.addToCustomContentPage(customContent, callbacks);
Adam Cohenbffe7452013-07-22 18:21:45 -0700979 return mQsbScroller;
Adam Cohen66a01fd2013-06-11 12:48:00 -0700980 }
981
Adam Cohenedb40762013-07-18 16:45:45 -0700982 // The custom content needs to offset its content to account for the QSB
983 public int getTopOffsetForCustomContent() {
984 return mWorkspace.getPaddingTop();
985 }
986
Jeffrey Sharkey99c87582009-03-24 17:59:43 -0700987 @Override
988 public Object onRetainNonConfigurationInstance() {
Joe Onorato9c1289c2009-08-17 11:03:03 -0400989 // Flag the loader to stop early before switching
990 mModel.stopLoader();
Winson Chung785d2eb2011-04-14 16:08:02 -0700991 if (mAppsCustomizeContent != null) {
992 mAppsCustomizeContent.surrender();
993 }
Romain Guy13c2e7b2010-03-10 19:45:00 -0800994 return Boolean.TRUE;
Jeffrey Sharkey99c87582009-03-24 17:59:43 -0700995 }
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700996
Joe Onorato2d7e7d02010-01-29 15:57:19 -0800997 // We can't hide the IME if it was forced open. So don't bother
998 /*
999 @Override
1000 public void onWindowFocusChanged(boolean hasFocus) {
1001 super.onWindowFocusChanged(hasFocus);
1002
1003 if (hasFocus) {
1004 final InputMethodManager inputManager = (InputMethodManager)
1005 getSystemService(Context.INPUT_METHOD_SERVICE);
1006 WindowManager.LayoutParams lp = getWindow().getAttributes();
1007 inputManager.hideSoftInputFromWindow(lp.token, 0, new android.os.ResultReceiver(new
1008 android.os.Handler()) {
1009 protected void onReceiveResult(int resultCode, Bundle resultData) {
1010 Log.d(TAG, "ResultReceiver got resultCode=" + resultCode);
1011 }
1012 });
1013 Log.d(TAG, "called hideSoftInputFromWindow from onWindowFocusChanged");
1014 }
1015 }
1016 */
1017
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001018 private boolean acceptFilter() {
1019 final InputMethodManager inputManager = (InputMethodManager)
1020 getSystemService(Context.INPUT_METHOD_SERVICE);
1021 return !inputManager.isFullscreenMode();
1022 }
1023
1024 @Override
1025 public boolean onKeyDown(int keyCode, KeyEvent event) {
Winson Chung97d85d22011-04-13 11:27:36 -07001026 final int uniChar = event.getUnicodeChar();
1027 final boolean handled = super.onKeyDown(keyCode, event);
1028 final boolean isKeyNotWhitespace = uniChar > 0 && !Character.isWhitespace(uniChar);
1029 if (!handled && acceptFilter() && isKeyNotWhitespace) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001030 boolean gotKey = TextKeyListener.getInstance().onKeyDown(mWorkspace, mDefaultKeySsb,
1031 keyCode, event);
1032 if (gotKey && mDefaultKeySsb != null && mDefaultKeySsb.length() > 0) {
Karl Rosaen138a0412009-04-23 19:00:21 -07001033 // something usable has been typed - start a search
Romain Guycbb89e42009-06-08 15:52:54 -07001034 // the typed text will be retrieved and cleared by
Karl Rosaen138a0412009-04-23 19:00:21 -07001035 // showSearchDialog()
1036 // If there are multiple keystrokes before the search dialog takes focus,
1037 // onSearchRequested() will be called for every keystroke,
1038 // but it is idempotent, so it's fine.
1039 return onSearchRequested();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001040 }
1041 }
1042
Joe Onorato8a9625e2010-01-28 15:55:35 -08001043 // Eat the long press event so the keyboard doesn't come up.
1044 if (keyCode == KeyEvent.KEYCODE_MENU && event.isLongPress()) {
1045 return true;
1046 }
1047
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001048 return handled;
1049 }
1050
Karl Rosaen138a0412009-04-23 19:00:21 -07001051 private String getTypedText() {
1052 return mDefaultKeySsb.toString();
1053 }
1054
1055 private void clearTypedText() {
1056 mDefaultKeySsb.clear();
1057 mDefaultKeySsb.clearSpans();
1058 Selection.setSelection(mDefaultKeySsb, 0);
1059 }
1060
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001061 /**
Michael Jurka883f55b2010-10-21 15:47:14 -07001062 * Given the integer (ordinal) value of a State enum instance, convert it to a variable of type
1063 * State
1064 */
1065 private static State intToState(int stateOrdinal) {
1066 State state = State.WORKSPACE;
1067 final State[] stateValues = State.values();
1068 for (int i = 0; i < stateValues.length; i++) {
1069 if (stateValues[i].ordinal() == stateOrdinal) {
1070 state = stateValues[i];
1071 break;
1072 }
1073 }
1074 return state;
1075 }
1076
1077 /**
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001078 * Restores the previous state, if it exists.
1079 *
1080 * @param savedState The previous state.
1081 */
1082 private void restoreState(Bundle savedState) {
1083 if (savedState == null) {
1084 return;
1085 }
1086
Michael Jurka883f55b2010-10-21 15:47:14 -07001087 State state = intToState(savedState.getInt(RUNTIME_STATE, State.WORKSPACE.ordinal()));
Winson Chungf0ea4d32011-06-06 14:27:16 -07001088 if (state == State.APPS_CUSTOMIZE) {
Winson Chung4a2afa32012-07-19 14:53:05 -07001089 mOnResumeState = State.APPS_CUSTOMIZE;
Joe Onorato3a8820b2009-11-10 15:06:42 -08001090 }
1091
Winson Chungf0c6ae02012-03-21 16:10:31 -07001092 int currentScreen = savedState.getInt(RUNTIME_STATE_CURRENT_SCREEN, -1);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001093 if (currentScreen > -1) {
Winson Chung8c87cd82013-07-23 16:20:10 -07001094 mWorkspace.setRestorePage(currentScreen);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001095 }
1096
Winson Chung3d503fb2011-07-13 17:25:49 -07001097 final long pendingAddContainer = savedState.getLong(RUNTIME_STATE_PENDING_ADD_CONTAINER, -1);
Adam Cohendcd297f2013-06-18 13:13:40 -07001098 final long pendingAddScreen = savedState.getLong(RUNTIME_STATE_PENDING_ADD_SCREEN, -1);
Michael Jurka0280c3b2010-09-17 15:00:07 -07001099
Winson Chung3d503fb2011-07-13 17:25:49 -07001100 if (pendingAddContainer != ItemInfo.NO_ID && pendingAddScreen > -1) {
1101 mPendingAddInfo.container = pendingAddContainer;
Adam Cohendcd297f2013-06-18 13:13:40 -07001102 mPendingAddInfo.screenId = pendingAddScreen;
Winson Chung3d503fb2011-07-13 17:25:49 -07001103 mPendingAddInfo.cellX = savedState.getInt(RUNTIME_STATE_PENDING_ADD_CELL_X);
1104 mPendingAddInfo.cellY = savedState.getInt(RUNTIME_STATE_PENDING_ADD_CELL_Y);
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001105 mPendingAddInfo.spanX = savedState.getInt(RUNTIME_STATE_PENDING_ADD_SPAN_X);
1106 mPendingAddInfo.spanY = savedState.getInt(RUNTIME_STATE_PENDING_ADD_SPAN_Y);
1107 mPendingAddWidgetInfo = savedState.getParcelable(RUNTIME_STATE_PENDING_ADD_WIDGET_INFO);
Adam Cohen87a9f5b2012-05-29 16:16:51 -07001108 mWaitingForResult = true;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001109 mRestoring = true;
1110 }
1111
1112 boolean renameFolder = savedState.getBoolean(RUNTIME_STATE_PENDING_FOLDER_RENAME, false);
1113 if (renameFolder) {
1114 long id = savedState.getLong(RUNTIME_STATE_PENDING_FOLDER_RENAME_ID);
Brad Fitzpatrick319226a2010-09-01 13:45:16 -07001115 mFolderInfo = mModel.getFolderById(this, sFolders, id);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001116 mRestoring = true;
1117 }
Winson Chunga12a2502010-12-20 14:41:35 -08001118
Winson Chung785d2eb2011-04-14 16:08:02 -07001119 // Restore the AppsCustomize tab
1120 if (mAppsCustomizeTabHost != null) {
1121 String curTab = savedState.getString("apps_customize_currentTab");
1122 if (curTab != null) {
Winson Chungc93e5ae2012-07-23 20:48:26 -07001123 mAppsCustomizeTabHost.setContentTypeImmediate(
Winson Chung785d2eb2011-04-14 16:08:02 -07001124 mAppsCustomizeTabHost.getContentTypeForTabTag(curTab));
Winson Chungf314b0e2011-08-16 11:54:27 -07001125 mAppsCustomizeContent.loadAssociatedPages(
1126 mAppsCustomizeContent.getCurrentPage());
Winson Chung785d2eb2011-04-14 16:08:02 -07001127 }
1128
Winson Chung5afbf7b2011-07-25 11:53:08 -07001129 int currentIndex = savedState.getInt("apps_customize_currentIndex");
1130 mAppsCustomizeContent.restorePageForIndex(currentIndex);
Winson Chung785d2eb2011-04-14 16:08:02 -07001131 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001132 }
1133
1134 /**
1135 * Finds all the views we need and configure them properly.
1136 */
1137 private void setupViews() {
Michael Jurkaa63c4522010-08-19 13:52:27 -07001138 final DragController dragController = mDragController;
Joe Onorato00acb122009-08-04 16:04:30 -04001139
Craig Mautner360310b2012-10-26 15:13:08 -07001140 mLauncherView = findViewById(R.id.launcher);
Winson Chung4c98d922011-05-31 16:50:48 -07001141 mDragLayer = (DragLayer) findViewById(R.id.drag_layer);
1142 mWorkspace = (Workspace) mDragLayer.findViewById(R.id.workspace);
Craig Mautner360310b2012-10-26 15:13:08 -07001143
John Spurlock77e1f472013-09-11 10:09:51 -04001144 mLauncherView.setSystemUiVisibility(
1145 View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION);
Craig Mautner360310b2012-10-26 15:13:08 -07001146 mWorkspaceBackgroundDrawable = getResources().getDrawable(R.drawable.workspace_bg);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001147
Winson Chung4c98d922011-05-31 16:50:48 -07001148 // Setup the drag layer
1149 mDragLayer.setup(this, dragController);
1150
Winson Chung3d503fb2011-07-13 17:25:49 -07001151 // Setup the hotseat
1152 mHotseat = (Hotseat) findViewById(R.id.hotseat);
1153 if (mHotseat != null) {
1154 mHotseat.setup(this);
Winson Chung11a1a532013-09-13 11:14:45 -07001155 mHotseat.setOnLongClickListener(this);
Winson Chung3d503fb2011-07-13 17:25:49 -07001156 }
1157
Adam Cohenf358a4b2013-07-23 16:47:31 -07001158 mOverviewPanel = findViewById(R.id.overview_panel);
Adam Cohen61f560d2013-09-30 15:58:20 -07001159 View widgetButton = findViewById(R.id.widget_button);
1160 widgetButton.setOnClickListener(new OnClickListener() {
Adam Cohenf358a4b2013-07-23 16:47:31 -07001161 @Override
1162 public void onClick(View arg0) {
Winson Chungc58497e2013-09-03 17:48:37 -07001163 showAllApps(true, AppsCustomizePagedView.ContentType.Widgets);
Adam Cohenf358a4b2013-07-23 16:47:31 -07001164 }
1165 });
Adam Cohen61f560d2013-09-30 15:58:20 -07001166 widgetButton.setOnTouchListener(getHapticFeedbackTouchListener());
1167
1168 View wallpaperButton = findViewById(R.id.wallpaper_button);
1169 wallpaperButton.setOnClickListener(new OnClickListener() {
Adam Cohenf358a4b2013-07-23 16:47:31 -07001170 @Override
1171 public void onClick(View arg0) {
1172 startWallpaper();
1173 }
1174 });
Adam Cohen61f560d2013-09-30 15:58:20 -07001175 wallpaperButton.setOnTouchListener(getHapticFeedbackTouchListener());
1176
1177 View settingsButton = findViewById(R.id.settings_button);
1178 settingsButton.setOnClickListener(new OnClickListener() {
Adam Cohen30bacb22013-08-29 14:25:25 -07001179 @Override
1180 public void onClick(View arg0) {
1181 startSettings();
1182 }
1183 });
Adam Cohen61f560d2013-09-30 15:58:20 -07001184 settingsButton.setOnTouchListener(getHapticFeedbackTouchListener());
Adam Cohendbdff6b2013-09-18 19:09:15 -07001185 mOverviewPanel.setAlpha(0f);
Adam Cohenf358a4b2013-07-23 16:47:31 -07001186
Winson Chung4c98d922011-05-31 16:50:48 -07001187 // Setup the workspace
1188 mWorkspace.setHapticFeedbackEnabled(false);
1189 mWorkspace.setOnLongClickListener(this);
Adam Cohencff6af82011-09-13 14:51:53 -07001190 mWorkspace.setup(dragController);
Michael Jurkad74c9842011-07-10 12:44:21 -07001191 dragController.addDragListener(mWorkspace);
Winson Chung4c98d922011-05-31 16:50:48 -07001192
Winson Chungf0ea4d32011-06-06 14:27:16 -07001193 // Get the search/delete bar
Winson Chungc51db6a2011-10-05 11:44:49 -07001194 mSearchDropTargetBar = (SearchDropTargetBar) mDragLayer.findViewById(R.id.qsb_bar);
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07001195
Winson Chungf0ea4d32011-06-06 14:27:16 -07001196 // Setup AppsCustomize
Craig Mautner360310b2012-10-26 15:13:08 -07001197 mAppsCustomizeTabHost = (AppsCustomizeTabHost) findViewById(R.id.apps_customize_pane);
Winson Chungf0ea4d32011-06-06 14:27:16 -07001198 mAppsCustomizeContent = (AppsCustomizePagedView)
1199 mAppsCustomizeTabHost.findViewById(R.id.apps_customize_pane_content);
1200 mAppsCustomizeContent.setup(this, dragController);
Craig Mautner360310b2012-10-26 15:13:08 -07001201
Winson Chung3d503fb2011-07-13 17:25:49 -07001202 // Setup the drag controller (drop targets have to be added in reverse order in priority)
Winson Chung4c98d922011-05-31 16:50:48 -07001203 dragController.setDragScoller(mWorkspace);
1204 dragController.setScrollView(mDragLayer);
1205 dragController.setMoveTarget(mWorkspace);
1206 dragController.addDropTarget(mWorkspace);
Winson Chungc51db6a2011-10-05 11:44:49 -07001207 if (mSearchDropTargetBar != null) {
1208 mSearchDropTargetBar.setup(this, dragController);
Michael Jurkae0f5a612011-02-07 16:45:41 -08001209 }
Daniel Sandler924b9932013-06-12 00:38:25 -04001210
Daniel Sandlera127b7a2013-06-17 14:25:46 -04001211 if (getResources().getBoolean(R.bool.debug_memory_enabled)) {
Daniel Sandler924b9932013-06-12 00:38:25 -04001212 Log.v(TAG, "adding WeightWatcher");
Adam Cohen39a06042013-07-19 14:30:12 -07001213 mWeightWatcher = new WeightWatcher(this);
1214 mWeightWatcher.setAlpha(0.5f);
1215 ((FrameLayout) mLauncherView).addView(mWeightWatcher,
Daniel Sandler924b9932013-06-12 00:38:25 -04001216 new FrameLayout.LayoutParams(
1217 FrameLayout.LayoutParams.MATCH_PARENT,
Daniel Sandlerb9eb2862013-06-14 20:17:30 -04001218 FrameLayout.LayoutParams.WRAP_CONTENT,
Daniel Sandler924b9932013-06-12 00:38:25 -04001219 Gravity.BOTTOM)
1220 );
Adam Cohen39a06042013-07-19 14:30:12 -07001221
1222 boolean show = shouldShowWeightWatcher();
1223 mWeightWatcher.setVisibility(show ? View.VISIBLE : View.GONE);
Daniel Sandler924b9932013-06-12 00:38:25 -04001224 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001225 }
1226
1227 /**
1228 * Creates a view representing a shortcut.
1229 *
1230 * @param info The data structure describing the shortcut.
1231 *
1232 * @return A View inflated from R.layout.application.
1233 */
Joe Onorato0589f0f2010-02-08 13:44:00 -08001234 View createShortcut(ShortcutInfo info) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001235 return createShortcut(R.layout.application,
Michael Jurka0142d492010-08-25 17:46:15 -07001236 (ViewGroup) mWorkspace.getChildAt(mWorkspace.getCurrentPage()), info);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001237 }
1238
1239 /**
1240 * Creates a view representing a shortcut inflated from the specified resource.
1241 *
1242 * @param layoutResId The id of the XML layout used to create the shortcut.
1243 * @param parent The group the shortcut belongs to.
1244 * @param info The data structure describing the shortcut.
1245 *
1246 * @return A View inflated from layoutResId.
1247 */
Joe Onorato0589f0f2010-02-08 13:44:00 -08001248 View createShortcut(int layoutResId, ViewGroup parent, ShortcutInfo info) {
Michael Jurka67b2f6c2010-11-17 12:33:46 -08001249 BubbleTextView favorite = (BubbleTextView) mInflater.inflate(layoutResId, parent, false);
1250 favorite.applyFromShortcutInfo(info, mIconCache);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001251 favorite.setOnClickListener(this);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001252 return favorite;
1253 }
1254
1255 /**
1256 * Add an application shortcut to the workspace.
1257 *
1258 * @param data The intent describing the application.
1259 * @param cellInfo The position on screen where to create the shortcut.
1260 */
Adam Cohendcd297f2013-06-18 13:13:40 -07001261 void completeAddApplication(Intent data, long container, long screenId, int cellX, int cellY) {
Michael Jurka0280c3b2010-09-17 15:00:07 -07001262 final int[] cellXY = mTmpAddItemCellCoordinates;
Adam Cohendcd297f2013-06-18 13:13:40 -07001263 final CellLayout layout = getCellLayout(container, screenId);
Michael Jurka0280c3b2010-09-17 15:00:07 -07001264
Adam Cohenfbba09b2011-07-18 21:43:05 -07001265 // First we check if we already know the exact location where we want to add this item.
1266 if (cellX >= 0 && cellY >= 0) {
1267 cellXY[0] = cellX;
1268 cellXY[1] = cellY;
1269 } else if (!layout.findCellForSpan(cellXY, 1, 1)) {
Winson Chung93eef082012-03-23 15:59:27 -07001270 showOutOfSpaceMessage(isHotseatLayout(layout));
Michael Jurka0280c3b2010-09-17 15:00:07 -07001271 return;
1272 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001273
Patrick Dubroy002cbf42011-03-03 16:36:21 -08001274 final ShortcutInfo info = mModel.getShortcutInfo(getPackageManager(), data, this);
Joe Onorato0589f0f2010-02-08 13:44:00 -08001275
Romain Guy73b979d2009-06-09 12:57:21 -07001276 if (info != null) {
Michael Jurka1e2f4652013-07-08 18:03:46 -07001277 info.setActivity(this, data.getComponent(), Intent.FLAG_ACTIVITY_NEW_TASK |
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001278 Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
Joe Onorato0589f0f2010-02-08 13:44:00 -08001279 info.container = ItemInfo.NO_ID;
Adam Cohendcd297f2013-06-18 13:13:40 -07001280 mWorkspace.addApplicationShortcut(info, layout, container, screenId, cellXY[0], cellXY[1],
Adam Cohenfbba09b2011-07-18 21:43:05 -07001281 isWorkspaceLocked(), cellX, cellY);
Joe Onorato0589f0f2010-02-08 13:44:00 -08001282 } else {
1283 Log.e(TAG, "Couldn't find ActivityInfo for selected application: " + data);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001284 }
1285 }
Romain Guycbb89e42009-06-08 15:52:54 -07001286
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001287 /**
1288 * Add a shortcut to the workspace.
1289 *
1290 * @param data The intent describing the shortcut.
1291 * @param cellInfo The position on screen where to create the shortcut.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001292 */
Adam Cohendcd297f2013-06-18 13:13:40 -07001293 private void completeAddShortcut(Intent data, long container, long screenId, int cellX,
Winson Chung3d503fb2011-07-13 17:25:49 -07001294 int cellY) {
1295 int[] cellXY = mTmpAddItemCellCoordinates;
1296 int[] touchXY = mPendingAddInfo.dropPos;
Adam Cohendcd297f2013-06-18 13:13:40 -07001297 CellLayout layout = getCellLayout(container, screenId);
Romain Guycbb89e42009-06-08 15:52:54 -07001298
Michael Jurkad3ef3062010-11-23 16:23:58 -08001299 boolean foundCellSpan = false;
Adam Cohenfbba09b2011-07-18 21:43:05 -07001300
Adam Cohen558baaf2011-08-15 15:22:57 -07001301 ShortcutInfo info = mModel.infoFromShortcutIntent(this, data, null);
Adam Cohend9198822011-11-22 16:42:47 -08001302 if (info == null) {
1303 return;
1304 }
Adam Cohen558baaf2011-08-15 15:22:57 -07001305 final View view = createShortcut(info);
1306
Adam Cohenfbba09b2011-07-18 21:43:05 -07001307 // First we check if we already know the exact location where we want to add this item.
1308 if (cellX >= 0 && cellY >= 0) {
1309 cellXY[0] = cellX;
1310 cellXY[1] = cellY;
1311 foundCellSpan = true;
Adam Cohen558baaf2011-08-15 15:22:57 -07001312
1313 // If appropriate, either create a folder or add to an existing folder
Adam Cohen482ed822012-03-02 14:15:13 -08001314 if (mWorkspace.createUserFolderIfNecessary(view, container, layout, cellXY, 0,
Adam Cohen558baaf2011-08-15 15:22:57 -07001315 true, null,null)) {
1316 return;
1317 }
1318 DragObject dragObject = new DragObject();
1319 dragObject.dragInfo = info;
Adam Cohen482ed822012-03-02 14:15:13 -08001320 if (mWorkspace.addToExistingFolderIfNecessary(view, layout, cellXY, 0, dragObject,
1321 true)) {
Adam Cohen558baaf2011-08-15 15:22:57 -07001322 return;
1323 }
Adam Cohenfbba09b2011-07-18 21:43:05 -07001324 } else if (touchXY != null) {
Michael Jurkad3ef3062010-11-23 16:23:58 -08001325 // when dragging and dropping, just find the closest free spot
Winson Chung3d503fb2011-07-13 17:25:49 -07001326 int[] result = layout.findNearestVacantArea(touchXY[0], touchXY[1], 1, 1, cellXY);
Michael Jurkad3ef3062010-11-23 16:23:58 -08001327 foundCellSpan = (result != null);
1328 } else {
Adam Cohenfbba09b2011-07-18 21:43:05 -07001329 foundCellSpan = layout.findCellForSpan(cellXY, 1, 1);
Michael Jurkad3ef3062010-11-23 16:23:58 -08001330 }
1331
1332 if (!foundCellSpan) {
Winson Chung93eef082012-03-23 15:59:27 -07001333 showOutOfSpaceMessage(isHotseatLayout(layout));
Michael Jurka0280c3b2010-09-17 15:00:07 -07001334 return;
1335 }
1336
Adam Cohendcd297f2013-06-18 13:13:40 -07001337 LauncherModel.addItemToDatabase(this, info, container, screenId, cellXY[0], cellXY[1], false);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001338
1339 if (!mRestoring) {
Adam Cohendcd297f2013-06-18 13:13:40 -07001340 mWorkspace.addInScreen(view, container, screenId, cellXY[0], cellXY[1], 1, 1,
Winson Chung3d503fb2011-07-13 17:25:49 -07001341 isWorkspaceLocked());
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001342 }
1343 }
1344
Adam Cohen2f093b62012-04-30 18:59:53 -07001345 static int[] getSpanForWidget(Context context, ComponentName component, int minWidth,
1346 int minHeight) {
1347 Rect padding = AppWidgetHostView.getDefaultPaddingForWidget(context, component, null);
Adam Cohenf814aa02011-09-01 13:48:05 -07001348 // We want to account for the extra amount of padding that we are adding to the widget
1349 // to ensure that it gets the full amount of space that it has requested
1350 int requiredWidth = minWidth + padding.left + padding.right;
1351 int requiredHeight = minHeight + padding.top + padding.bottom;
Winson Chung66700732013-08-20 16:56:15 -07001352 return CellLayout.rectToCell(requiredWidth, requiredHeight, null);
Adam Cohenf814aa02011-09-01 13:48:05 -07001353 }
1354
Adam Cohen2f093b62012-04-30 18:59:53 -07001355 static int[] getSpanForWidget(Context context, AppWidgetProviderInfo info) {
1356 return getSpanForWidget(context, info.provider, info.minWidth, info.minHeight);
Adam Cohenf814aa02011-09-01 13:48:05 -07001357 }
1358
Adam Cohen2f093b62012-04-30 18:59:53 -07001359 static int[] getMinSpanForWidget(Context context, AppWidgetProviderInfo info) {
1360 return getSpanForWidget(context, info.provider, info.minResizeWidth, info.minResizeHeight);
Adam Cohencbf47e32011-09-16 17:32:37 -07001361 }
1362
Adam Cohen2f093b62012-04-30 18:59:53 -07001363 static int[] getSpanForWidget(Context context, PendingAddWidgetInfo info) {
1364 return getSpanForWidget(context, info.componentName, info.minWidth, info.minHeight);
Adam Cohenf814aa02011-09-01 13:48:05 -07001365 }
1366
Adam Cohen2f093b62012-04-30 18:59:53 -07001367 static int[] getMinSpanForWidget(Context context, PendingAddWidgetInfo info) {
1368 return getSpanForWidget(context, info.componentName, info.minResizeWidth,
Winson Chunga5c96362012-04-12 14:04:41 -07001369 info.minResizeHeight);
Adam Cohend41fbf52012-02-16 23:53:59 -08001370 }
1371
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001372 /**
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001373 * Add a widget to the workspace.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001374 *
Romain Guy5bbc91b2010-08-18 11:38:46 -07001375 * @param appWidgetId The app widget id
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001376 * @param cellInfo The position on screen where to create the widget.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001377 */
Adam Cohendcd297f2013-06-18 13:13:40 -07001378 private void completeAddAppWidget(final int appWidgetId, long container, long screenId,
Adam Cohened66b2b2012-01-23 17:28:51 -08001379 AppWidgetHostView hostView, AppWidgetProviderInfo appWidgetInfo) {
1380 if (appWidgetInfo == null) {
1381 appWidgetInfo = mAppWidgetManager.getAppWidgetInfo(appWidgetId);
1382 }
Romain Guycbb89e42009-06-08 15:52:54 -07001383
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001384 // Calculate the grid spans needed to fit this widget
Adam Cohendcd297f2013-06-18 13:13:40 -07001385 CellLayout layout = getCellLayout(container, screenId);
Adam Cohen09353862011-07-14 16:10:03 -07001386
Adam Cohen2f093b62012-04-30 18:59:53 -07001387 int[] minSpanXY = getMinSpanForWidget(this, appWidgetInfo);
1388 int[] spanXY = getSpanForWidget(this, appWidgetInfo);
Romain Guycbb89e42009-06-08 15:52:54 -07001389
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001390 // Try finding open space on Launcher screen
Michael Jurkaa63c4522010-08-19 13:52:27 -07001391 // We have saved the position to which the widget was dragged-- this really only matters
1392 // if we are placing widgets on a "spring-loaded" screen
Winson Chung3d503fb2011-07-13 17:25:49 -07001393 int[] cellXY = mTmpAddItemCellCoordinates;
1394 int[] touchXY = mPendingAddInfo.dropPos;
Adam Cohend41fbf52012-02-16 23:53:59 -08001395 int[] finalSpan = new int[2];
Michael Jurka0280c3b2010-09-17 15:00:07 -07001396 boolean foundCellSpan = false;
Winson Chung3d503fb2011-07-13 17:25:49 -07001397 if (mPendingAddInfo.cellX >= 0 && mPendingAddInfo.cellY >= 0) {
1398 cellXY[0] = mPendingAddInfo.cellX;
1399 cellXY[1] = mPendingAddInfo.cellY;
Adam Cohend41fbf52012-02-16 23:53:59 -08001400 spanXY[0] = mPendingAddInfo.spanX;
1401 spanXY[1] = mPendingAddInfo.spanY;
Adam Cohenfbba09b2011-07-18 21:43:05 -07001402 foundCellSpan = true;
1403 } else if (touchXY != null) {
Michael Jurka0280c3b2010-09-17 15:00:07 -07001404 // when dragging and dropping, just find the closest free spot
Winson Chung3d503fb2011-07-13 17:25:49 -07001405 int[] result = layout.findNearestVacantArea(
Adam Cohend41fbf52012-02-16 23:53:59 -08001406 touchXY[0], touchXY[1], minSpanXY[0], minSpanXY[1], spanXY[0],
1407 spanXY[1], cellXY, finalSpan);
1408 spanXY[0] = finalSpan[0];
1409 spanXY[1] = finalSpan[1];
Michael Jurkad3ef3062010-11-23 16:23:58 -08001410 foundCellSpan = (result != null);
Michael Jurka0280c3b2010-09-17 15:00:07 -07001411 } else {
Adam Cohend41fbf52012-02-16 23:53:59 -08001412 foundCellSpan = layout.findCellForSpan(cellXY, minSpanXY[0], minSpanXY[1]);
Michael Jurkaa63c4522010-08-19 13:52:27 -07001413 }
1414
Michael Jurka0280c3b2010-09-17 15:00:07 -07001415 if (!foundCellSpan) {
Winson Chungf7640c82011-02-28 13:47:29 -08001416 if (appWidgetId != -1) {
1417 // Deleting an app widget ID is a void call but writes to disk before returning
1418 // to the caller...
Winson Chungf7640c82011-02-28 13:47:29 -08001419 new Thread("deleteAppWidgetId") {
1420 public void run() {
1421 mAppWidgetHost.deleteAppWidgetId(appWidgetId);
1422 }
1423 }.start();
1424 }
Winson Chung93eef082012-03-23 15:59:27 -07001425 showOutOfSpaceMessage(isHotseatLayout(layout));
Romain Guy18042c82009-11-06 11:44:55 -08001426 return;
1427 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001428
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001429 // Build Launcher-specific widget info and save to database
Winson Chung11a49372012-04-27 15:12:38 -07001430 LauncherAppWidgetInfo launcherInfo = new LauncherAppWidgetInfo(appWidgetId,
1431 appWidgetInfo.provider);
Michael Jurka0280c3b2010-09-17 15:00:07 -07001432 launcherInfo.spanX = spanXY[0];
1433 launcherInfo.spanY = spanXY[1];
Adam Cohend41fbf52012-02-16 23:53:59 -08001434 launcherInfo.minSpanX = mPendingAddInfo.minSpanX;
1435 launcherInfo.minSpanY = mPendingAddInfo.minSpanY;
Romain Guycbb89e42009-06-08 15:52:54 -07001436
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001437 LauncherModel.addItemToDatabase(this, launcherInfo,
Adam Cohendcd297f2013-06-18 13:13:40 -07001438 container, screenId, cellXY[0], cellXY[1], false);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001439
1440 if (!mRestoring) {
Adam Cohened66b2b2012-01-23 17:28:51 -08001441 if (hostView == null) {
1442 // Perform actual inflation because we're live
1443 launcherInfo.hostView = mAppWidgetHost.createView(this, appWidgetId, appWidgetInfo);
1444 launcherInfo.hostView.setAppWidget(appWidgetId, appWidgetInfo);
1445 } else {
1446 // The AppWidgetHostView has already been inflated and instantiated
1447 launcherInfo.hostView = hostView;
1448 }
Romain Guycbb89e42009-06-08 15:52:54 -07001449
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001450 launcherInfo.hostView.setTag(launcherInfo);
Adam Cohend41fbf52012-02-16 23:53:59 -08001451 launcherInfo.hostView.setVisibility(View.VISIBLE);
Adam Cohenaaa5c212012-10-05 18:14:31 -07001452 launcherInfo.notifyWidgetSizeChanged(this);
1453
Adam Cohendcd297f2013-06-18 13:13:40 -07001454 mWorkspace.addInScreen(launcherInfo.hostView, container, screenId, cellXY[0], cellXY[1],
Joe Onorato9c1289c2009-08-17 11:03:03 -04001455 launcherInfo.spanX, launcherInfo.spanY, isWorkspaceLocked());
Adam Cohended9f8d2010-11-03 13:25:16 -07001456
1457 addWidgetToAutoAdvanceIfNeeded(launcherInfo.hostView, appWidgetInfo);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001458 }
Adam Cohen6af9af02012-02-02 15:41:45 -08001459 resetAddInfo();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001460 }
Romain Guycbb89e42009-06-08 15:52:54 -07001461
Adam Cohended9f8d2010-11-03 13:25:16 -07001462 private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
1463 @Override
1464 public void onReceive(Context context, Intent intent) {
1465 final String action = intent.getAction();
1466 if (Intent.ACTION_SCREEN_OFF.equals(action)) {
1467 mUserPresent = false;
Adam Cohenbec6ac52011-07-19 20:50:27 -07001468 mDragLayer.clearAllResizeFrames();
Adam Cohended9f8d2010-11-03 13:25:16 -07001469 updateRunning();
Winson Chung337cd9d2011-03-30 10:39:30 -07001470
Winson Chungc100e8e2011-08-09 16:02:43 -07001471 // Reset AllApps to its initial state only if we are not in the middle of
Winson Chungb8472bb2011-08-05 13:49:21 -07001472 // processing a multi-step drop
Winson Chungc100e8e2011-08-09 16:02:43 -07001473 if (mAppsCustomizeTabHost != null && mPendingAddInfo.container == ItemInfo.NO_ID) {
Adam Cohen040a5d22013-09-16 17:09:33 -07001474 showWorkspaceAndExitOverviewMode(false);
Winson Chung785d2eb2011-04-14 16:08:02 -07001475 }
Adam Cohended9f8d2010-11-03 13:25:16 -07001476 } else if (Intent.ACTION_USER_PRESENT.equals(action)) {
1477 mUserPresent = true;
1478 updateRunning();
1479 }
1480 }
1481 };
1482
1483 @Override
1484 public void onAttachedToWindow() {
1485 super.onAttachedToWindow();
1486
1487 // Listen for broadcasts related to user-presence
1488 final IntentFilter filter = new IntentFilter();
1489 filter.addAction(Intent.ACTION_SCREEN_OFF);
1490 filter.addAction(Intent.ACTION_USER_PRESENT);
1491 registerReceiver(mReceiver, filter);
Michael Jurkaf1ad6082013-03-13 12:55:46 +01001492 FirstFrameAnimatorHelper.initializeDrawListener(getWindow().getDecorView());
Adam Cohend113e0c2010-11-11 10:48:05 -08001493 mAttached = true;
Adam Cohended9f8d2010-11-03 13:25:16 -07001494 mVisible = true;
1495 }
1496
1497 @Override
1498 public void onDetachedFromWindow() {
1499 super.onDetachedFromWindow();
1500 mVisible = false;
1501
Adam Cohend113e0c2010-11-11 10:48:05 -08001502 if (mAttached) {
1503 unregisterReceiver(mReceiver);
1504 mAttached = false;
1505 }
Adam Cohended9f8d2010-11-03 13:25:16 -07001506 updateRunning();
1507 }
1508
1509 public void onWindowVisibilityChanged(int visibility) {
1510 mVisible = visibility == View.VISIBLE;
1511 updateRunning();
Michael Jurka2a4b1a82011-12-07 14:00:02 -08001512 // The following code used to be in onResume, but it turns out onResume is called when
1513 // you're in All Apps and click home to go to the workspace. onWindowVisibilityChanged
1514 // is a more appropriate event to handle
1515 if (mVisible) {
1516 mAppsCustomizeTabHost.onWindowVisible();
1517 if (!mWorkspaceLoading) {
1518 final ViewTreeObserver observer = mWorkspace.getViewTreeObserver();
Michael Jurka2a4b1a82011-12-07 14:00:02 -08001519 // We want to let Launcher draw itself at least once before we force it to build
1520 // layers on all the workspace pages, so that transitioning to Launcher from other
Michael Jurkaf1ad6082013-03-13 12:55:46 +01001521 // apps is nice and speedy.
1522 observer.addOnDrawListener(new ViewTreeObserver.OnDrawListener() {
Michael Jurkadf96add2013-04-03 16:25:02 -07001523 private boolean mStarted = false;
Michael Jurkaf1ad6082013-03-13 12:55:46 +01001524 public void onDraw() {
Michael Jurkadf96add2013-04-03 16:25:02 -07001525 if (mStarted) return;
1526 mStarted = true;
Michael Jurka6ee21d22012-02-21 18:20:27 -08001527 // We delay the layer building a bit in order to give
1528 // other message processing a time to run. In particular
1529 // this avoids a delay in hiding the IME if it was
1530 // currently shown, because doing that may involve
1531 // some communication back with the app.
Winson Chungaeae56b2012-02-24 15:47:27 -08001532 mWorkspace.postDelayed(mBuildLayersRunnable, 500);
Michael Jurkadf96add2013-04-03 16:25:02 -07001533 final ViewTreeObserver.OnDrawListener listener = this;
1534 mWorkspace.post(new Runnable() {
1535 public void run() {
Michael Jurkab68e03a2013-04-11 11:36:41 -07001536 if (mWorkspace != null &&
1537 mWorkspace.getViewTreeObserver() != null) {
1538 mWorkspace.getViewTreeObserver().
1539 removeOnDrawListener(listener);
1540 }
Michael Jurkadf96add2013-04-03 16:25:02 -07001541 }
1542 });
Michael Jurkaf1ad6082013-03-13 12:55:46 +01001543 return;
Michael Jurka2a4b1a82011-12-07 14:00:02 -08001544 }
1545 });
1546 }
Michael Jurka6ee21d22012-02-21 18:20:27 -08001547 // When Launcher comes back to foreground, a different Activity might be responsible for
1548 // the app market intent, so refresh the icon
Winson Chungd64a6662013-09-30 11:06:59 -07001549 if (!DISABLE_MARKET_BUTTON) {
1550 updateAppMarketIcon();
1551 }
Michael Jurka2a4b1a82011-12-07 14:00:02 -08001552 clearTypedText();
1553 }
Adam Cohended9f8d2010-11-03 13:25:16 -07001554 }
1555
1556 private void sendAdvanceMessage(long delay) {
1557 mHandler.removeMessages(ADVANCE_MSG);
1558 Message msg = mHandler.obtainMessage(ADVANCE_MSG);
1559 mHandler.sendMessageDelayed(msg, delay);
1560 mAutoAdvanceSentTime = System.currentTimeMillis();
1561 }
1562
1563 private void updateRunning() {
1564 boolean autoAdvanceRunning = mVisible && mUserPresent && !mWidgetsToAdvance.isEmpty();
1565 if (autoAdvanceRunning != mAutoAdvanceRunning) {
1566 mAutoAdvanceRunning = autoAdvanceRunning;
1567 if (autoAdvanceRunning) {
1568 long delay = mAutoAdvanceTimeLeft == -1 ? mAdvanceInterval : mAutoAdvanceTimeLeft;
1569 sendAdvanceMessage(delay);
1570 } else {
1571 if (!mWidgetsToAdvance.isEmpty()) {
1572 mAutoAdvanceTimeLeft = Math.max(0, mAdvanceInterval -
1573 (System.currentTimeMillis() - mAutoAdvanceSentTime));
1574 }
1575 mHandler.removeMessages(ADVANCE_MSG);
Patrick Dubroy2313eff2011-01-11 20:01:31 -08001576 mHandler.removeMessages(0); // Remove messages sent using postDelayed()
Adam Cohended9f8d2010-11-03 13:25:16 -07001577 }
1578 }
1579 }
1580
1581 private final Handler mHandler = new Handler() {
1582 @Override
1583 public void handleMessage(Message msg) {
1584 if (msg.what == ADVANCE_MSG) {
1585 int i = 0;
1586 for (View key: mWidgetsToAdvance.keySet()) {
1587 final View v = key.findViewById(mWidgetsToAdvance.get(key).autoAdvanceViewId);
1588 final int delay = mAdvanceStagger * i;
1589 if (v instanceof Advanceable) {
1590 postDelayed(new Runnable() {
1591 public void run() {
1592 ((Advanceable) v).advance();
1593 }
1594 }, delay);
1595 }
1596 i++;
1597 }
1598 sendAdvanceMessage(mAdvanceInterval);
1599 }
1600 }
1601 };
1602
1603 void addWidgetToAutoAdvanceIfNeeded(View hostView, AppWidgetProviderInfo appWidgetInfo) {
Adam Cohen292c0252011-07-18 13:55:17 -07001604 if (appWidgetInfo == null || appWidgetInfo.autoAdvanceViewId == -1) return;
Adam Cohended9f8d2010-11-03 13:25:16 -07001605 View v = hostView.findViewById(appWidgetInfo.autoAdvanceViewId);
1606 if (v instanceof Advanceable) {
1607 mWidgetsToAdvance.put(hostView, appWidgetInfo);
Adam Cohen2ddf13e2011-01-19 21:26:33 -08001608 ((Advanceable) v).fyiWillBeAdvancedByHostKThx();
Adam Cohended9f8d2010-11-03 13:25:16 -07001609 updateRunning();
1610 }
1611 }
1612
1613 void removeWidgetToAutoAdvance(View hostView) {
1614 if (mWidgetsToAdvance.containsKey(hostView)) {
1615 mWidgetsToAdvance.remove(hostView);
1616 updateRunning();
1617 }
Michael Jurka0280c3b2010-09-17 15:00:07 -07001618 }
1619
Joe Onorato9c1289c2009-08-17 11:03:03 -04001620 public void removeAppWidget(LauncherAppWidgetInfo launcherInfo) {
Adam Cohended9f8d2010-11-03 13:25:16 -07001621 removeWidgetToAutoAdvance(launcherInfo.hostView);
Joe Onorato9c1289c2009-08-17 11:03:03 -04001622 launcherInfo.hostView = null;
1623 }
1624
Winson Chung93eef082012-03-23 15:59:27 -07001625 void showOutOfSpaceMessage(boolean isHotseatLayout) {
1626 int strId = (isHotseatLayout ? R.string.hotseat_out_of_space : R.string.out_of_space);
1627 Toast.makeText(this, getString(strId), Toast.LENGTH_SHORT).show();
Adam Cohended9f8d2010-11-03 13:25:16 -07001628 }
1629
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001630 public LauncherAppWidgetHost getAppWidgetHost() {
1631 return mAppWidgetHost;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001632 }
Romain Guycbb89e42009-06-08 15:52:54 -07001633
Winson Chunga9abd0e2010-10-27 17:18:37 -07001634 public LauncherModel getModel() {
1635 return mModel;
1636 }
1637
Bjorn Bringertc459e522013-06-07 19:36:01 +01001638 public void closeSystemDialogs() {
Joe Onorato2ca0ae72009-11-10 13:14:13 -08001639 getWindow().closeAllPanels();
1640
Joe Onoratoa5c32d62009-11-19 10:28:49 -08001641 // Whatever we were doing is hereby canceled.
1642 mWaitingForResult = false;
Joe Onorato2ca0ae72009-11-10 13:14:13 -08001643 }
1644
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001645 @Override
1646 protected void onNewIntent(Intent intent) {
Michael Jurka447bf842013-05-15 14:52:15 +02001647 long startTime = 0;
1648 if (DEBUG_RESUME_TIME) {
1649 startTime = System.currentTimeMillis();
1650 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001651 super.onNewIntent(intent);
1652
1653 // Close the menu
1654 if (Intent.ACTION_MAIN.equals(intent.getAction())) {
Joe Onoratoa5c32d62009-11-19 10:28:49 -08001655 // also will cancel mWaitingForResult.
Joe Onorato2ca0ae72009-11-10 13:14:13 -08001656 closeSystemDialogs();
Jason Samsfd22dac2009-09-20 17:24:16 -07001657
Jamie Genniscb222e82012-10-23 15:44:26 -07001658 final boolean alreadyOnHome =
1659 ((intent.getFlags() & Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT)
Joe Onorato14f122b2009-11-19 14:06:36 -08001660 != Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT);
Michael Jurka01f0ed42010-08-20 00:41:17 -07001661
Jamie Genniscb222e82012-10-23 15:44:26 -07001662 Runnable processIntent = new Runnable() {
1663 public void run() {
Michael Jurkaffc26822012-11-16 18:21:22 -08001664 if (mWorkspace == null) {
1665 // Can be cases where mWorkspace is null, this prevents a NPE
1666 return;
1667 }
Jamie Genniscb222e82012-10-23 15:44:26 -07001668 Folder openFolder = mWorkspace.getOpenFolder();
1669 // In all these cases, only animate if we're already on home
1670 mWorkspace.exitWidgetResizeMode();
1671 if (alreadyOnHome && mState == State.WORKSPACE && !mWorkspace.isTouchActive() &&
1672 openFolder == null) {
1673 mWorkspace.moveToDefaultScreen(true);
1674 }
Adam Cohenac56cff2011-09-28 20:45:37 -07001675
Jamie Genniscb222e82012-10-23 15:44:26 -07001676 closeFolder();
1677 exitSpringLoadedDragMode();
Winson Chung4a2afa32012-07-19 14:53:05 -07001678
Jamie Genniscb222e82012-10-23 15:44:26 -07001679 // If we are already on home, then just animate back to the workspace,
1680 // otherwise, just wait until onResume to set the state back to Workspace
1681 if (alreadyOnHome) {
Adam Cohen040a5d22013-09-16 17:09:33 -07001682 showWorkspaceAndExitOverviewMode(true);
Jamie Genniscb222e82012-10-23 15:44:26 -07001683 } else {
1684 mOnResumeState = State.WORKSPACE;
1685 }
1686
1687 final View v = getWindow().peekDecorView();
1688 if (v != null && v.getWindowToken() != null) {
1689 InputMethodManager imm = (InputMethodManager)getSystemService(
1690 INPUT_METHOD_SERVICE);
1691 imm.hideSoftInputFromWindow(v.getWindowToken(), 0);
1692 }
1693
Winson Chung7819a562013-09-19 15:55:45 -07001694 // Reset the apps customize page
1695 if (mAppsCustomizeTabHost != null) {
Jamie Genniscb222e82012-10-23 15:44:26 -07001696 mAppsCustomizeTabHost.reset();
1697 }
1698 }
1699 };
1700
1701 if (alreadyOnHome && !mWorkspace.hasWindowFocus()) {
1702 // Delay processing of the intent to allow the status bar animation to finish
1703 // first in order to avoid janky animations.
1704 mWorkspace.postDelayed(processIntent, 350);
Winson Chung4a2afa32012-07-19 14:53:05 -07001705 } else {
Jamie Genniscb222e82012-10-23 15:44:26 -07001706 // Process the intent immediately.
1707 processIntent.run();
Winson Chung4a2afa32012-07-19 14:53:05 -07001708 }
Romain Guy1dd3a072009-07-16 13:21:01 -07001709
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001710 }
Michael Jurka447bf842013-05-15 14:52:15 +02001711 if (DEBUG_RESUME_TIME) {
1712 Log.d(TAG, "Time spent in onNewIntent: " + (System.currentTimeMillis() - startTime));
1713 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001714 }
1715
Adam Cohen040a5d22013-09-16 17:09:33 -07001716 protected void showWorkspaceAndExitOverviewMode(boolean animate) {
1717 showWorkspace(animate);
Allan Wojciechowskiaf110e82013-09-12 10:48:23 +01001718 if (mWorkspace.isInOverviewMode()) {
Adam Cohen040a5d22013-09-16 17:09:33 -07001719 mWorkspace.exitOverviewMode(animate);
Allan Wojciechowskiaf110e82013-09-12 10:48:23 +01001720 }
1721 }
Adam Cohen040a5d22013-09-16 17:09:33 -07001722 protected void showWorkspaceAndExitOverviewMode() {
Allan Wojciechowskifdc43022013-10-02 11:13:17 -04001723 showWorkspaceAndExitOverviewMode(false);
Adam Cohen040a5d22013-09-16 17:09:33 -07001724 }
Allan Wojciechowskiaf110e82013-09-12 10:48:23 +01001725
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001726 @Override
Adam Cohen1462de32012-07-24 22:34:36 -07001727 public void onRestoreInstanceState(Bundle state) {
1728 super.onRestoreInstanceState(state);
1729 for (int page: mSynchronouslyBoundPages) {
1730 mWorkspace.restoreInstanceStateForChild(page);
1731 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001732 }
1733
1734 @Override
1735 protected void onSaveInstanceState(Bundle outState) {
Winson Chungc93e5ae2012-07-23 20:48:26 -07001736 outState.putInt(RUNTIME_STATE_CURRENT_SCREEN, mWorkspace.getNextPage());
Adam Cohen95bb8002011-07-03 23:40:28 -07001737 super.onSaveInstanceState(outState);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001738
Michael Jurka883f55b2010-10-21 15:47:14 -07001739 outState.putInt(RUNTIME_STATE, mState.ordinal());
Adam Cohen51e95032011-07-11 14:44:19 -07001740 // We close any open folder since it will not be re-opened, and we need to make sure
1741 // this state is reflected.
1742 closeFolder();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001743
Adam Cohendcd297f2013-06-18 13:13:40 -07001744 if (mPendingAddInfo.container != ItemInfo.NO_ID && mPendingAddInfo.screenId > -1 &&
Winson Chung3d503fb2011-07-13 17:25:49 -07001745 mWaitingForResult) {
1746 outState.putLong(RUNTIME_STATE_PENDING_ADD_CONTAINER, mPendingAddInfo.container);
Adam Cohendcd297f2013-06-18 13:13:40 -07001747 outState.putLong(RUNTIME_STATE_PENDING_ADD_SCREEN, mPendingAddInfo.screenId);
Winson Chung3d503fb2011-07-13 17:25:49 -07001748 outState.putInt(RUNTIME_STATE_PENDING_ADD_CELL_X, mPendingAddInfo.cellX);
1749 outState.putInt(RUNTIME_STATE_PENDING_ADD_CELL_Y, mPendingAddInfo.cellY);
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001750 outState.putInt(RUNTIME_STATE_PENDING_ADD_SPAN_X, mPendingAddInfo.spanX);
1751 outState.putInt(RUNTIME_STATE_PENDING_ADD_SPAN_Y, mPendingAddInfo.spanY);
1752 outState.putParcelable(RUNTIME_STATE_PENDING_ADD_WIDGET_INFO, mPendingAddWidgetInfo);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001753 }
1754
1755 if (mFolderInfo != null && mWaitingForResult) {
1756 outState.putBoolean(RUNTIME_STATE_PENDING_FOLDER_RENAME, true);
1757 outState.putLong(RUNTIME_STATE_PENDING_FOLDER_RENAME_ID, mFolderInfo.id);
1758 }
Michael Jurka946ad472010-07-09 18:05:18 -07001759
Winson Chung785d2eb2011-04-14 16:08:02 -07001760 // Save the current AppsCustomize tab
1761 if (mAppsCustomizeTabHost != null) {
1762 String currentTabTag = mAppsCustomizeTabHost.getCurrentTabTag();
1763 if (currentTabTag != null) {
1764 outState.putString("apps_customize_currentTab", currentTabTag);
1765 }
Winson Chung5afbf7b2011-07-25 11:53:08 -07001766 int currentIndex = mAppsCustomizeContent.getSaveInstanceStateIndex();
1767 outState.putInt("apps_customize_currentIndex", currentIndex);
Winson Chung785d2eb2011-04-14 16:08:02 -07001768 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001769 }
1770
1771 @Override
1772 public void onDestroy() {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001773 super.onDestroy();
Romain Guycbb89e42009-06-08 15:52:54 -07001774
Winson Chunge7a03942011-08-05 15:05:12 -07001775 // Remove all pending runnables
1776 mHandler.removeMessages(ADVANCE_MSG);
1777 mHandler.removeMessages(0);
Michael Jurka9d906c72011-10-14 06:25:36 -07001778 mWorkspace.removeCallbacks(mBuildLayersRunnable);
Winson Chunge7a03942011-08-05 15:05:12 -07001779
Winson Chungcd2b0142011-06-08 16:02:26 -07001780 // Stop callbacks from LauncherModel
Daniel Sandlercc8befa2013-06-11 14:45:48 -04001781 LauncherAppState app = (LauncherAppState.getInstance());
Winson Chungcd2b0142011-06-08 16:02:26 -07001782 mModel.stopLoader();
1783 app.setLauncher(null);
1784
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001785 try {
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001786 mAppWidgetHost.stopListening();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001787 } catch (NullPointerException ex) {
Joe Onoratoa30ce8e2009-11-11 08:16:49 -08001788 Log.w(TAG, "problem while stopping AppWidgetHost during Launcher destruction", ex);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001789 }
Patrick Dubroy2313eff2011-01-11 20:01:31 -08001790 mAppWidgetHost = null;
1791
1792 mWidgetsToAdvance.clear();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001793
1794 TextKeyListener.getInstance().release();
1795
Winson Chung81b52252012-08-27 15:34:29 -07001796 // Disconnect any of the callbacks and drawables associated with ItemInfos on the workspace
1797 // to prevent leaking Launcher activities on orientation change.
1798 if (mModel != null) {
1799 mModel.unbindItemInfosAndClearQueuedBindRunnables();
1800 }
Jeff Sharkey1e2efc82009-11-06 15:17:59 -08001801
1802 getContentResolver().unregisterContentObserver(mWidgetObserver);
Joe Onorato34a0e1b2009-12-14 17:44:51 -08001803 unregisterReceiver(mCloseSystemDialogsReceiver);
Patrick Dubroy2313eff2011-01-11 20:01:31 -08001804
Adam Cohenaccf3bf2012-04-30 16:07:43 -07001805 mDragLayer.clearAllResizeFrames();
Patrick Dubroy2313eff2011-01-11 20:01:31 -08001806 ((ViewGroup) mWorkspace.getParent()).removeAllViews();
1807 mWorkspace.removeAllViews();
1808 mWorkspace = null;
1809 mDragController = null;
Patrick Dubroy60b7c532011-01-16 17:19:32 -08001810
Michael Jurka2ecf9952012-06-18 12:52:28 -07001811 LauncherAnimUtils.onDestroyActivity();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001812 }
1813
Adam Cohena9cf38f2011-05-02 15:36:58 -07001814 public DragController getDragController() {
1815 return mDragController;
1816 }
1817
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001818 @Override
1819 public void startActivityForResult(Intent intent, int requestCode) {
Romain Guy08f97492009-06-29 14:41:20 -07001820 if (requestCode >= 0) mWaitingForResult = true;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001821 super.startActivityForResult(intent, requestCode);
1822 }
1823
Winson Chung70d72102011-08-12 11:24:35 -07001824 /**
1825 * Indicates that we want global search for this activity by setting the globalSearch
1826 * argument for {@link #startSearch} to true.
1827 */
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001828 @Override
Romain Guycbb89e42009-06-08 15:52:54 -07001829 public void startSearch(String initialQuery, boolean selectInitialQuery,
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001830 Bundle appSearchData, boolean globalSearch) {
Karl Rosaen138a0412009-04-23 19:00:21 -07001831
Michael Jurkac0e8fca2010-10-06 16:41:29 -07001832 showWorkspace(true);
Romain Guycbb89e42009-06-08 15:52:54 -07001833
Karl Rosaen138a0412009-04-23 19:00:21 -07001834 if (initialQuery == null) {
1835 // Use any text typed in the launcher as the initial query
1836 initialQuery = getTypedText();
Karl Rosaen138a0412009-04-23 19:00:21 -07001837 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001838 if (appSearchData == null) {
1839 appSearchData = new Bundle();
Bjorn Bringert32b12d22013-06-06 13:00:41 +01001840 appSearchData.putString("source", "launcher-search");
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001841 }
Winson Chungadf0c182012-08-23 14:59:07 -07001842 Rect sourceBounds = new Rect();
1843 if (mSearchDropTargetBar != null) {
1844 sourceBounds = mSearchDropTargetBar.getSearchBarBounds();
1845 }
Romain Guycbb89e42009-06-08 15:52:54 -07001846
Bjorn Bringertc459e522013-06-07 19:36:01 +01001847 startSearch(initialQuery, selectInitialQuery,
1848 appSearchData, sourceBounds);
1849 }
1850
1851 public void startSearch(String initialQuery,
1852 boolean selectInitialQuery, Bundle appSearchData, Rect sourceBounds) {
Michael Jurkaa33411c2012-06-14 16:18:21 -07001853 startGlobalSearch(initialQuery, selectInitialQuery,
Bjorn Bringertc459e522013-06-07 19:36:01 +01001854 appSearchData, sourceBounds);
Michael Jurkaa33411c2012-06-14 16:18:21 -07001855 }
1856
1857 /**
1858 * Starts the global search activity. This code is a copied from SearchManager
1859 */
Bjorn Bringertc459e522013-06-07 19:36:01 +01001860 private void startGlobalSearch(String initialQuery,
Michael Jurkaa33411c2012-06-14 16:18:21 -07001861 boolean selectInitialQuery, Bundle appSearchData, Rect sourceBounds) {
Karl Rosaen138a0412009-04-23 19:00:21 -07001862 final SearchManager searchManager =
Michael Jurkaa33411c2012-06-14 16:18:21 -07001863 (SearchManager) getSystemService(Context.SEARCH_SERVICE);
1864 ComponentName globalSearchActivity = searchManager.getGlobalSearchActivity();
1865 if (globalSearchActivity == null) {
1866 Log.w(TAG, "No global search activity found.");
1867 return;
1868 }
1869 Intent intent = new Intent(SearchManager.INTENT_ACTION_GLOBAL_SEARCH);
1870 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
1871 intent.setComponent(globalSearchActivity);
1872 // Make sure that we have a Bundle to put source in
1873 if (appSearchData == null) {
1874 appSearchData = new Bundle();
1875 } else {
1876 appSearchData = new Bundle(appSearchData);
1877 }
1878 // Set source to package name of app that starts global search, if not set already.
1879 if (!appSearchData.containsKey("source")) {
1880 appSearchData.putString("source", getPackageName());
1881 }
1882 intent.putExtra(SearchManager.APP_DATA, appSearchData);
1883 if (!TextUtils.isEmpty(initialQuery)) {
1884 intent.putExtra(SearchManager.QUERY, initialQuery);
1885 }
1886 if (selectInitialQuery) {
1887 intent.putExtra(SearchManager.EXTRA_SELECT_QUERY, selectInitialQuery);
1888 }
1889 intent.setSourceBounds(sourceBounds);
1890 try {
1891 startActivity(intent);
1892 } catch (ActivityNotFoundException ex) {
1893 Log.e(TAG, "Global search activity not found: " + globalSearchActivity);
1894 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001895 }
1896
Winson Chung70d72102011-08-12 11:24:35 -07001897 @Override
Winson Chung70d72102011-08-12 11:24:35 -07001898 public boolean onPrepareOptionsMenu(Menu menu) {
1899 super.onPrepareOptionsMenu(menu);
Michael Jurkab94f3f82013-09-11 18:08:54 +02001900 if (!mWorkspace.isInOverviewMode()) {
1901 mWorkspace.enterOverviewMode();
Winson Chung70d72102011-08-12 11:24:35 -07001902 }
Michael Jurkab94f3f82013-09-11 18:08:54 +02001903 return false;
Winson Chung70d72102011-08-12 11:24:35 -07001904 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001905
The Android Open Source Projectca9475f2009-03-13 13:04:24 -07001906 @Override
1907 public boolean onSearchRequested() {
Romain Guycbb89e42009-06-08 15:52:54 -07001908 startSearch(null, false, null, true);
Amith Yamasania135ba82011-08-09 17:42:01 -07001909 // Use a custom animation for launching search
Karl Rosaen138a0412009-04-23 19:00:21 -07001910 return true;
The Android Open Source Projectca9475f2009-03-13 13:04:24 -07001911 }
1912
Joe Onorato9c1289c2009-08-17 11:03:03 -04001913 public boolean isWorkspaceLocked() {
1914 return mWorkspaceLoading || mWaitingForResult;
1915 }
1916
Michael Jurka0280c3b2010-09-17 15:00:07 -07001917 private void resetAddInfo() {
Winson Chung3d503fb2011-07-13 17:25:49 -07001918 mPendingAddInfo.container = ItemInfo.NO_ID;
Adam Cohendcd297f2013-06-18 13:13:40 -07001919 mPendingAddInfo.screenId = -1;
Winson Chung3d503fb2011-07-13 17:25:49 -07001920 mPendingAddInfo.cellX = mPendingAddInfo.cellY = -1;
1921 mPendingAddInfo.spanX = mPendingAddInfo.spanY = -1;
Adam Cohend41fbf52012-02-16 23:53:59 -08001922 mPendingAddInfo.minSpanX = mPendingAddInfo.minSpanY = -1;
Winson Chung3d503fb2011-07-13 17:25:49 -07001923 mPendingAddInfo.dropPos = null;
Michael Jurka0280c3b2010-09-17 15:00:07 -07001924 }
Michael Jurkaa63c4522010-08-19 13:52:27 -07001925
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001926 void addAppWidgetImpl(final int appWidgetId, ItemInfo info, AppWidgetHostView boundWidget,
1927 AppWidgetProviderInfo appWidgetInfo) {
1928 if (appWidgetInfo.configure != null) {
1929 mPendingAddWidgetInfo = appWidgetInfo;
Michael Jurkaaf442092010-06-10 17:01:57 -07001930
Bjorn Bringert7984c942009-12-09 15:38:25 +00001931 // Launch over to configure widget, if needed
1932 Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_CONFIGURE);
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001933 intent.setComponent(appWidgetInfo.configure);
Bjorn Bringert7984c942009-12-09 15:38:25 +00001934 intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId);
Michael Jurkaa805e1a2013-08-22 15:00:33 +02001935 Utilities.startActivityForResultSafely(this, intent, REQUEST_CREATE_APPWIDGET);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001936 } else {
Bjorn Bringert7984c942009-12-09 15:38:25 +00001937 // Otherwise just add it
Adam Cohendcd297f2013-06-18 13:13:40 -07001938 completeAddAppWidget(appWidgetId, info.container, info.screenId, boundWidget,
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001939 appWidgetInfo);
Winson Chung557d6ed2011-07-08 15:34:52 -07001940 // Exit spring loaded mode if necessary after adding the widget
Adam Cohened66b2b2012-01-23 17:28:51 -08001941 exitSpringLoadedDragModeDelayed(true, false, null);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001942 }
1943 }
Romain Guycbb89e42009-06-08 15:52:54 -07001944
Allan Wojciechowskiaf110e82013-09-12 10:48:23 +01001945 protected void moveToCustomContentScreen(boolean animate) {
Sandeep Siddharthaf2b47f12013-09-26 19:49:27 -07001946 // Close any folders that may be open.
1947 closeFolder();
Allan Wojciechowskiaf110e82013-09-12 10:48:23 +01001948 mWorkspace.moveToCustomContentScreen(animate);
1949 }
Adam Cohenfbba09b2011-07-18 21:43:05 -07001950 /**
1951 * Process a shortcut drop.
1952 *
1953 * @param componentName The name of the component
Adam Cohendcd297f2013-06-18 13:13:40 -07001954 * @param screenId The ID of the screen where it should be added
Adam Cohenfbba09b2011-07-18 21:43:05 -07001955 * @param cell The cell it should be added to, optional
1956 * @param position The location on the screen where it was dropped, optional
1957 */
Adam Cohendcd297f2013-06-18 13:13:40 -07001958 void processShortcutFromDrop(ComponentName componentName, long container, long screenId,
Winson Chung3d503fb2011-07-13 17:25:49 -07001959 int[] cell, int[] loc) {
Michael Jurka0280c3b2010-09-17 15:00:07 -07001960 resetAddInfo();
Winson Chung3d503fb2011-07-13 17:25:49 -07001961 mPendingAddInfo.container = container;
Adam Cohendcd297f2013-06-18 13:13:40 -07001962 mPendingAddInfo.screenId = screenId;
Winson Chung3d503fb2011-07-13 17:25:49 -07001963 mPendingAddInfo.dropPos = loc;
Adam Cohenfbba09b2011-07-18 21:43:05 -07001964
1965 if (cell != null) {
Winson Chung3d503fb2011-07-13 17:25:49 -07001966 mPendingAddInfo.cellX = cell[0];
1967 mPendingAddInfo.cellY = cell[1];
Adam Cohenfbba09b2011-07-18 21:43:05 -07001968 }
Michael Jurka0280c3b2010-09-17 15:00:07 -07001969
1970 Intent createShortcutIntent = new Intent(Intent.ACTION_CREATE_SHORTCUT);
1971 createShortcutIntent.setComponent(componentName);
1972 processShortcut(createShortcutIntent);
1973 }
1974
Adam Cohenfbba09b2011-07-18 21:43:05 -07001975 /**
1976 * Process a widget drop.
1977 *
1978 * @param info The PendingAppWidgetInfo of the widget being added.
Adam Cohendcd297f2013-06-18 13:13:40 -07001979 * @param screenId The ID of the screen where it should be added
Adam Cohenfbba09b2011-07-18 21:43:05 -07001980 * @param cell The cell it should be added to, optional
1981 * @param position The location on the screen where it was dropped, optional
1982 */
Adam Cohendcd297f2013-06-18 13:13:40 -07001983 void addAppWidgetFromDrop(PendingAddWidgetInfo info, long container, long screenId,
Adam Cohend41fbf52012-02-16 23:53:59 -08001984 int[] cell, int[] span, int[] loc) {
Adam Cohenfbba09b2011-07-18 21:43:05 -07001985 resetAddInfo();
Winson Chung3d503fb2011-07-13 17:25:49 -07001986 mPendingAddInfo.container = info.container = container;
Adam Cohendcd297f2013-06-18 13:13:40 -07001987 mPendingAddInfo.screenId = info.screenId = screenId;
Winson Chung3d503fb2011-07-13 17:25:49 -07001988 mPendingAddInfo.dropPos = loc;
Adam Cohend41fbf52012-02-16 23:53:59 -08001989 mPendingAddInfo.minSpanX = info.minSpanX;
1990 mPendingAddInfo.minSpanY = info.minSpanY;
1991
Adam Cohenfbba09b2011-07-18 21:43:05 -07001992 if (cell != null) {
Winson Chung3d503fb2011-07-13 17:25:49 -07001993 mPendingAddInfo.cellX = cell[0];
1994 mPendingAddInfo.cellY = cell[1];
Adam Cohenfbba09b2011-07-18 21:43:05 -07001995 }
Adam Cohend41fbf52012-02-16 23:53:59 -08001996 if (span != null) {
1997 mPendingAddInfo.spanX = span[0];
1998 mPendingAddInfo.spanY = span[1];
1999 }
Adam Cohenfbba09b2011-07-18 21:43:05 -07002000
Adam Cohened66b2b2012-01-23 17:28:51 -08002001 AppWidgetHostView hostView = info.boundWidget;
2002 int appWidgetId;
2003 if (hostView != null) {
2004 appWidgetId = hostView.getAppWidgetId();
Adam Cohen9d5b7d82012-05-09 18:00:44 -07002005 addAppWidgetImpl(appWidgetId, info, hostView, info.info);
Adam Cohened66b2b2012-01-23 17:28:51 -08002006 } else {
Adam Cohen9d5b7d82012-05-09 18:00:44 -07002007 // In this case, we either need to start an activity to get permission to bind
2008 // the widget, or we need to start an activity to configure the widget, or both.
Adam Cohened66b2b2012-01-23 17:28:51 -08002009 appWidgetId = getAppWidgetHost().allocateAppWidgetId();
Adam Cohendd70d662012-10-04 16:53:44 -07002010 Bundle options = info.bindOptions;
2011
2012 boolean success = false;
2013 if (options != null) {
2014 success = mAppWidgetManager.bindAppWidgetIdIfAllowed(appWidgetId,
2015 info.componentName, options);
2016 } else {
2017 success = mAppWidgetManager.bindAppWidgetIdIfAllowed(appWidgetId,
2018 info.componentName);
2019 }
2020 if (success) {
Adam Cohen9d5b7d82012-05-09 18:00:44 -07002021 addAppWidgetImpl(appWidgetId, info, null, info.info);
Michael Jurka8b805b12012-04-18 14:23:14 -07002022 } else {
Adam Cohen9d5b7d82012-05-09 18:00:44 -07002023 mPendingAddWidgetInfo = info.info;
Michael Jurka8b805b12012-04-18 14:23:14 -07002024 Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_BIND);
2025 intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId);
2026 intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_PROVIDER, info.componentName);
Adam Cohendd70d662012-10-04 16:53:44 -07002027 // TODO: we need to make sure that this accounts for the options bundle.
2028 // intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_OPTIONS, options);
Michael Jurka8b805b12012-04-18 14:23:14 -07002029 startActivityForResult(intent, REQUEST_BIND_APPWIDGET);
2030 }
Adam Cohened66b2b2012-01-23 17:28:51 -08002031 }
Adam Cohenfbba09b2011-07-18 21:43:05 -07002032 }
2033
Joe Onoratodeb98af2010-02-19 14:59:39 -08002034 void processShortcut(Intent intent) {
Jeffrey Sharkeyc7fdae12009-03-24 20:41:22 -07002035 // Handle case where user selected "Applications"
2036 String applicationName = getResources().getString(R.string.group_applications);
2037 String shortcutName = intent.getStringExtra(Intent.EXTRA_SHORTCUT_NAME);
Romain Guycbb89e42009-06-08 15:52:54 -07002038
Jeffrey Sharkeyc7fdae12009-03-24 20:41:22 -07002039 if (applicationName != null && applicationName.equals(shortcutName)) {
2040 Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
2041 mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);
Romain Guycbb89e42009-06-08 15:52:54 -07002042
Jeffrey Sharkeyc7fdae12009-03-24 20:41:22 -07002043 Intent pickIntent = new Intent(Intent.ACTION_PICK_ACTIVITY);
2044 pickIntent.putExtra(Intent.EXTRA_INTENT, mainIntent);
Winson Chung58f20882010-10-01 13:44:56 -07002045 pickIntent.putExtra(Intent.EXTRA_TITLE, getText(R.string.title_select_application));
Michael Jurkaa805e1a2013-08-22 15:00:33 +02002046 Utilities.startActivityForResultSafely(this, pickIntent, REQUEST_PICK_APPLICATION);
Jeffrey Sharkeyc7fdae12009-03-24 20:41:22 -07002047 } else {
Michael Jurkaa805e1a2013-08-22 15:00:33 +02002048 Utilities.startActivityForResultSafely(this, intent, REQUEST_CREATE_SHORTCUT);
Jeffrey Sharkeyc7fdae12009-03-24 20:41:22 -07002049 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002050 }
2051
Winson Chung24ab2f12010-09-16 14:10:47 -07002052 void processWallpaper(Intent intent) {
2053 startActivityForResult(intent, REQUEST_PICK_WALLPAPER);
2054 }
2055
Adam Cohendcd297f2013-06-18 13:13:40 -07002056 FolderIcon addFolder(CellLayout layout, long container, final long screenId, int cellX,
Winson Chung3d503fb2011-07-13 17:25:49 -07002057 int cellY) {
Michael Jurkac9d95c52011-08-29 14:03:34 -07002058 final FolderInfo folderInfo = new FolderInfo();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002059 folderInfo.title = getText(R.string.folder_name);
2060
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002061 // Update the model
Adam Cohendcd297f2013-06-18 13:13:40 -07002062 LauncherModel.addItemToDatabase(Launcher.this, folderInfo, container, screenId, cellX, cellY,
Winson Chung3d503fb2011-07-13 17:25:49 -07002063 false);
Brad Fitzpatrick319226a2010-09-01 13:45:16 -07002064 sFolders.put(folderInfo.id, folderInfo);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002065
2066 // Create the view
Winson Chung3d503fb2011-07-13 17:25:49 -07002067 FolderIcon newFolder =
2068 FolderIcon.fromXml(R.layout.folder_icon, this, layout, folderInfo, mIconCache);
Adam Cohendcd297f2013-06-18 13:13:40 -07002069 mWorkspace.addInScreen(newFolder, container, screenId, cellX, cellY, 1, 1,
Winson Chung3d503fb2011-07-13 17:25:49 -07002070 isWorkspaceLocked());
Winson Chung5f8afe62013-08-12 16:19:28 -07002071 // Force measure the new folder icon
2072 CellLayout parent = mWorkspace.getParentCellLayoutForView(newFolder);
2073 parent.getShortcutsAndWidgets().measureChild(newFolder);
Adam Cohendf035382011-04-11 17:22:04 -07002074 return newFolder;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002075 }
Romain Guycbb89e42009-06-08 15:52:54 -07002076
Joe Onorato9c1289c2009-08-17 11:03:03 -04002077 void removeFolder(FolderInfo folder) {
Brad Fitzpatrick319226a2010-09-01 13:45:16 -07002078 sFolders.remove(folder.id);
Joe Onorato9c1289c2009-08-17 11:03:03 -04002079 }
2080
Michael Jurkaeadbfc52013-09-04 00:45:37 +02002081 protected void startWallpaper() {
Michael Jurkac0e8fca2010-10-06 16:41:29 -07002082 showWorkspace(true);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002083 final Intent pickWallpaper = new Intent(Intent.ACTION_SET_WALLPAPER);
Michael Jurkaeadbfc52013-09-04 00:45:37 +02002084 pickWallpaper.setComponent(getWallpaperPickerComponent());
Michael Jurka104c4562013-07-08 18:03:46 -07002085 startActivityForResult(pickWallpaper, REQUEST_PICK_WALLPAPER);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002086 }
2087
Michael Jurkaeadbfc52013-09-04 00:45:37 +02002088 protected ComponentName getWallpaperPickerComponent() {
2089 return new ComponentName(getPackageName(), WallpaperPickerActivity.class.getName());
2090 }
2091
Joe Onorato2ca0ae72009-11-10 13:14:13 -08002092 /**
2093 * Registers various content observers. The current implementation registers
2094 * only a favorites observer to keep track of the favorites applications.
2095 */
Jeff Sharkey1e2efc82009-11-06 15:17:59 -08002096 private void registerContentObservers() {
2097 ContentResolver resolver = getContentResolver();
2098 resolver.registerContentObserver(LauncherProvider.CONTENT_APPWIDGET_RESET_URI,
2099 true, mWidgetObserver);
2100 }
2101
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002102 @Override
2103 public boolean dispatchKeyEvent(KeyEvent event) {
2104 if (event.getAction() == KeyEvent.ACTION_DOWN) {
2105 switch (event.getKeyCode()) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002106 case KeyEvent.KEYCODE_HOME:
Dianne Hackborn67800862009-07-24 17:15:20 -07002107 return true;
Joe Onoratobe386092009-11-17 17:32:16 -08002108 case KeyEvent.KEYCODE_VOLUME_DOWN:
Michael Jurka0a457bf2012-11-19 14:05:05 -08002109 if (isPropertyEnabled(DUMP_STATE_PROPERTY)) {
Joe Onoratobe386092009-11-17 17:32:16 -08002110 dumpState();
2111 return true;
2112 }
2113 break;
Dianne Hackborn67800862009-07-24 17:15:20 -07002114 }
2115 } else if (event.getAction() == KeyEvent.ACTION_UP) {
2116 switch (event.getKeyCode()) {
Dianne Hackborn67800862009-07-24 17:15:20 -07002117 case KeyEvent.KEYCODE_HOME:
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002118 return true;
2119 }
2120 }
2121
2122 return super.dispatchKeyEvent(event);
2123 }
2124
Joe Onorato88ec0992009-11-19 13:16:06 -08002125 @Override
2126 public void onBackPressed() {
Winson Chungc93e5ae2012-07-23 20:48:26 -07002127 if (isAllAppsVisible()) {
Michael Jurkac0e8fca2010-10-06 16:41:29 -07002128 showWorkspace(true);
Adam Cohenf358a4b2013-07-23 16:47:31 -07002129 } else if (mWorkspace.isInOverviewMode()) {
Michael Jurka336fd4f2013-09-12 00:05:02 +02002130 mWorkspace.exitOverviewMode(true);
Patrick Dubroy94f78a52011-02-28 17:39:16 -08002131 } else if (mWorkspace.getOpenFolder() != null) {
Adam Cohen76fc0852011-06-17 13:26:23 -07002132 Folder openFolder = mWorkspace.getOpenFolder();
2133 if (openFolder.isEditingName()) {
2134 openFolder.dismissEditingName();
2135 } else {
2136 closeFolder();
2137 }
Patrick Dubroy94f78a52011-02-28 17:39:16 -08002138 } else {
Patrick Dubroy758a9232011-03-03 19:54:56 -08002139 mWorkspace.exitWidgetResizeMode();
2140
Patrick Dubroy94f78a52011-02-28 17:39:16 -08002141 // Back button is a no-op here, but give at least some feedback for the button press
2142 mWorkspace.showOutlinesTemporarily();
Michael Jurkaaf442092010-06-10 17:01:57 -07002143 }
Joe Onorato88ec0992009-11-19 13:16:06 -08002144 }
2145
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002146 /**
Jeff Sharkey1e2efc82009-11-06 15:17:59 -08002147 * Re-listen when widgets are reset.
2148 */
2149 private void onAppWidgetReset() {
Michael Jurkabbbad6b2011-02-07 13:04:09 -08002150 if (mAppWidgetHost != null) {
2151 mAppWidgetHost.startListening();
2152 }
Jeff Sharkey1e2efc82009-11-06 15:17:59 -08002153 }
2154
2155 /**
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002156 * Launches the intent referred by the clicked shortcut.
2157 *
2158 * @param v The view representing the clicked shortcut.
2159 */
2160 public void onClick(View v) {
Adam Cohen9932a9b2011-08-02 22:14:07 -07002161 // Make sure that rogue clicks don't get through while allapps is launching, or after the
2162 // view has detached (it's possible for this to happen if the view is removed mid touch).
2163 if (v.getWindowToken() == null) {
2164 return;
2165 }
2166
Winson Chung9b0b2fe2012-02-24 13:03:34 -08002167 if (!mWorkspace.isFinishedSwitchingState()) {
Adam Cohen9932a9b2011-08-02 22:14:07 -07002168 return;
2169 }
Adam Cohen2f84ef22011-07-26 17:16:44 -07002170
Adam Cohen1697b792013-09-17 19:08:21 -07002171 if (v instanceof Workspace) {
2172 if (mWorkspace.isInOverviewMode()) {
2173 mWorkspace.exitOverviewMode(true);
Adam Cohenf358a4b2013-07-23 16:47:31 -07002174 }
2175 return;
2176 }
2177
2178 if (v instanceof CellLayout) {
2179 if (mWorkspace.isInOverviewMode()) {
Michael Jurka336fd4f2013-09-12 00:05:02 +02002180 mWorkspace.exitOverviewMode(mWorkspace.indexOfChild(v), true);
Adam Cohenf358a4b2013-07-23 16:47:31 -07002181 }
2182 }
2183
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002184 Object tag = v.getTag();
Joe Onorato0589f0f2010-02-08 13:44:00 -08002185 if (tag instanceof ShortcutInfo) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002186 // Open shortcut
Daniel Sandlerff02d492013-08-05 02:12:05 -04002187 final ShortcutInfo shortcut = (ShortcutInfo) tag;
2188 final Intent intent = shortcut.intent;
Adam Cohenb5fe60c2013-06-06 22:03:51 -07002189
Daniel Sandlerf8577a32013-06-26 14:04:59 -04002190 // Check for special shortcuts
2191 if (intent.getComponent() != null) {
2192 final String shortcutClass = intent.getComponent().getClassName();
2193
2194 if (shortcutClass.equals(WidgetAdder.class.getName())) {
Winson Chungc58497e2013-09-03 17:48:37 -07002195 showAllApps(true, AppsCustomizePagedView.ContentType.Widgets);
Daniel Sandlerf8577a32013-06-26 14:04:59 -04002196 return;
2197 } else if (shortcutClass.equals(MemoryDumpActivity.class.getName())) {
2198 MemoryDumpActivity.startDump(this);
2199 return;
Adam Cohen39a06042013-07-19 14:30:12 -07002200 } else if (shortcutClass.equals(ToggleWeightWatcher.class.getName())) {
2201 toggleShowWeightWatcher();
2202 return;
Daniel Sandlerf8577a32013-06-26 14:04:59 -04002203 }
Adam Cohenb5fe60c2013-06-06 22:03:51 -07002204 }
Daniel Sandlerf8577a32013-06-26 14:04:59 -04002205
2206 // Start activities
Joe Onorato13724ea2009-12-02 21:16:35 -08002207 int[] pos = new int[2];
2208 v.getLocationOnScreen(pos);
Romain Guyfb5411e2010-02-24 10:04:17 -08002209 intent.setSourceBounds(new Rect(pos[0], pos[1],
2210 pos[0] + v.getWidth(), pos[1] + v.getHeight()));
Winson Chungc7450e32012-04-17 17:34:08 -07002211
2212 boolean success = startActivitySafely(v, intent, tag);
Michael Jurkaddd62e92011-02-16 17:49:14 -08002213
Daniel Sandlerff02d492013-08-05 02:12:05 -04002214 mStats.recordLaunch(intent, shortcut);
2215
Michael Jurkaddd62e92011-02-16 17:49:14 -08002216 if (success && v instanceof BubbleTextView) {
2217 mWaitingForResume = (BubbleTextView) v;
2218 mWaitingForResume.setStayPressed(true);
2219 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002220 } else if (tag instanceof FolderInfo) {
Adam Cohena9cf38f2011-05-02 15:36:58 -07002221 if (v instanceof FolderIcon) {
2222 FolderIcon fi = (FolderIcon) v;
2223 handleFolderClick(fi);
2224 }
Winson Chungf0ea4d32011-06-06 14:27:16 -07002225 } else if (v == mAllAppsButton) {
Winson Chungc93e5ae2012-07-23 20:48:26 -07002226 if (isAllAppsVisible()) {
Michael Jurkac0e8fca2010-10-06 16:41:29 -07002227 showWorkspace(true);
Joe Onorato7404ee42009-07-31 11:54:44 -07002228 } else {
Michael Jurka2a552322011-10-11 15:22:05 -07002229 onClickAllAppsButton(v);
Joe Onorato7404ee42009-07-31 11:54:44 -07002230 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002231 }
2232 }
2233
Michael Jurka0e260592010-06-30 17:07:39 -07002234 public boolean onTouch(View v, MotionEvent event) {
Michael Jurka0e260592010-06-30 17:07:39 -07002235 return false;
2236 }
2237
Michael Jurkaaf442092010-06-10 17:01:57 -07002238 /**
Michael Jurka2c3af5f2010-08-03 13:53:20 -07002239 * Event handler for the search button
2240 *
2241 * @param v The view that was clicked.
2242 */
2243 public void onClickSearchButton(View v) {
Winson Chungbb185bd2011-11-21 12:31:42 -08002244 v.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY);
2245
Amith Yamasania135ba82011-08-09 17:42:01 -07002246 onSearchRequested();
Michael Jurka2c3af5f2010-08-03 13:53:20 -07002247 }
2248
2249 /**
Amith Yamasani6d7fe502010-11-16 09:05:07 -08002250 * Event handler for the voice button
2251 *
2252 * @param v The view that was clicked.
2253 */
2254 public void onClickVoiceButton(View v) {
Winson Chungbb185bd2011-11-21 12:31:42 -08002255 v.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY);
Amith Yamasani6d7fe502010-11-16 09:05:07 -08002256
Bjorn Bringertc459e522013-06-07 19:36:01 +01002257 startVoice();
2258 }
2259
2260 public void startVoice() {
Michael Jurkaae65ee32012-04-30 11:45:54 -07002261 try {
2262 final SearchManager searchManager =
2263 (SearchManager) getSystemService(Context.SEARCH_SERVICE);
2264 ComponentName activityName = searchManager.getGlobalSearchActivity();
2265 Intent intent = new Intent(RecognizerIntent.ACTION_WEB_SEARCH);
Andy Huangf615f712012-06-07 13:38:04 -07002266 intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
Michael Jurkaae65ee32012-04-30 11:45:54 -07002267 if (activityName != null) {
2268 intent.setPackage(activityName.getPackageName());
2269 }
Michael Jurka86a720e2012-05-09 11:23:23 -07002270 startActivity(null, intent, "onClickVoiceButton");
Michael Jurkaae65ee32012-04-30 11:45:54 -07002271 } catch (ActivityNotFoundException e) {
2272 Intent intent = new Intent(RecognizerIntent.ACTION_WEB_SEARCH);
Andy Huangf615f712012-06-07 13:38:04 -07002273 intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
Michael Jurkaae65ee32012-04-30 11:45:54 -07002274 startActivitySafely(null, intent, "onClickVoiceButton");
2275 }
Amith Yamasani6d7fe502010-11-16 09:05:07 -08002276 }
2277
2278 /**
Michael Jurka2c3af5f2010-08-03 13:53:20 -07002279 * Event handler for the "grid" button that appears on the home screen, which
2280 * enters all apps mode.
2281 *
2282 * @param v The view that was clicked.
2283 */
2284 public void onClickAllAppsButton(View v) {
Winson Chungc58497e2013-09-03 17:48:37 -07002285 showAllApps(true, AppsCustomizePagedView.ContentType.Applications);
Michael Jurka5130e402011-10-13 04:55:35 -07002286 }
2287
2288 public void onTouchDownAllAppsButton(View v) {
Michael Jurka2a552322011-10-11 15:22:05 -07002289 // Provide the same haptic feedback that the system offers for virtual keys.
2290 v.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY);
Michael Jurka2c3af5f2010-08-03 13:53:20 -07002291 }
2292
Adam Cohen61f560d2013-09-30 15:58:20 -07002293 public void performHapticFeedbackOnTouchDown(View v) {
2294 // Provide the same haptic feedback that the system offers for virtual keys.
2295 v.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY);
2296 }
2297
2298 public View.OnTouchListener getHapticFeedbackTouchListener() {
2299 if (mHapticFeedbackTouchListener == null) {
2300 mHapticFeedbackTouchListener = new View.OnTouchListener() {
2301 @Override
2302 public boolean onTouch(View v, MotionEvent event) {
2303 if ((event.getAction() & MotionEvent.ACTION_MASK) == MotionEvent.ACTION_DOWN) {
2304 v.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY);
2305 }
2306 return false;
2307 }
2308 };
2309 }
2310 return mHapticFeedbackTouchListener;
2311 }
2312
Patrick Dubroyceae05d2010-08-30 10:40:53 -07002313 public void onClickAppMarketButton(View v) {
Winson Chungd64a6662013-09-30 11:06:59 -07002314 if (!DISABLE_MARKET_BUTTON) {
2315 if (mAppMarketIntent != null) {
2316 startActivitySafely(v, mAppMarketIntent, "app market");
2317 } else {
2318 Log.e(TAG, "Invalid app market intent.");
2319 }
Patrick Dubroyceae05d2010-08-30 10:40:53 -07002320 }
2321 }
2322
Sandeep Siddharthaab2d9d72013-09-17 13:18:24 -07002323 /**
2324 * Called when the user stops interacting with the launcher.
2325 * This implies that the user is now on the homescreen and is not doing housekeeping.
2326 */
2327 protected void onInteractionEnd() {}
2328
2329 /**
2330 * Called when the user starts interacting with the launcher.
2331 * The possible interactions are:
2332 * - open all apps
2333 * - reorder an app shortcut, or a widget
2334 * - open the overview mode.
2335 * This is a good time to stop doing things that only make sense
2336 * when the user is on the homescreen and not doing housekeeping.
2337 */
2338 protected void onInteractionBegin() {}
2339
Patrick Dubroybc6840b2010-09-01 11:54:27 -07002340 void startApplicationDetailsActivity(ComponentName componentName) {
2341 String packageName = componentName.getPackageName();
Patrick Dubroy4ed62782010-08-17 15:11:18 -07002342 Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
2343 Uri.fromParts("package", packageName, null));
Winson Chungdff8ebb2011-09-08 17:25:31 -07002344 intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
Winson Chung3b1b36b2012-04-24 18:51:14 -07002345 startActivitySafely(null, intent, "startApplicationDetailsActivity");
Patrick Dubroy4ed62782010-08-17 15:11:18 -07002346 }
2347
Michael Jurka1e2f4652013-07-08 18:03:46 -07002348 // returns true if the activity was started
2349 boolean startApplicationUninstallActivity(ComponentName componentName, int flags) {
Michael Jurkaeadbfc52013-09-04 00:45:37 +02002350 if ((flags & AppInfo.DOWNLOADED_FLAG) == 0) {
Patrick Dubroy5539af72010-09-07 15:22:01 -07002351 // System applications cannot be installed. For now, show a toast explaining that.
2352 // We may give them the option of disabling apps this way.
2353 int messageId = R.string.uninstall_system_app_text;
2354 Toast.makeText(this, messageId, Toast.LENGTH_SHORT).show();
Michael Jurka1e2f4652013-07-08 18:03:46 -07002355 return false;
Patrick Dubroy5539af72010-09-07 15:22:01 -07002356 } else {
Michael Jurka1e2f4652013-07-08 18:03:46 -07002357 String packageName = componentName.getPackageName();
2358 String className = componentName.getClassName();
Patrick Dubroy5539af72010-09-07 15:22:01 -07002359 Intent intent = new Intent(
2360 Intent.ACTION_DELETE, Uri.fromParts("package", packageName, className));
Winson Chungdff8ebb2011-09-08 17:25:31 -07002361 intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK |
2362 Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
Patrick Dubroy5539af72010-09-07 15:22:01 -07002363 startActivity(intent);
Michael Jurka1e2f4652013-07-08 18:03:46 -07002364 return true;
Patrick Dubroy5539af72010-09-07 15:22:01 -07002365 }
Patrick Dubroybc6840b2010-09-01 11:54:27 -07002366 }
2367
Michael Jurka86a720e2012-05-09 11:23:23 -07002368 boolean startActivity(View v, Intent intent, Object tag) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002369 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
Winson Chungc7450e32012-04-17 17:34:08 -07002370
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002371 try {
Winson Chung2672ff92012-05-04 16:22:30 -07002372 // Only launch using the new animation if the shortcut has not opted out (this is a
2373 // private contract between launcher and may be ignored in the future).
2374 boolean useLaunchAnimation = (v != null) &&
2375 !intent.hasExtra(INTENT_EXTRA_IGNORE_LAUNCH_ANIMATION);
2376 if (useLaunchAnimation) {
Winson Chungc7450e32012-04-17 17:34:08 -07002377 ActivityOptions opts = ActivityOptions.makeScaleUpAnimation(v, 0, 0,
2378 v.getMeasuredWidth(), v.getMeasuredHeight());
2379
2380 startActivity(intent, opts.toBundle());
2381 } else {
2382 startActivity(intent);
2383 }
Michael Jurkaddd62e92011-02-16 17:49:14 -08002384 return true;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002385 } catch (SecurityException e) {
2386 Toast.makeText(this, R.string.activity_not_found, Toast.LENGTH_SHORT).show();
Joe Onoratoa30ce8e2009-11-11 08:16:49 -08002387 Log.e(TAG, "Launcher does not have the permission to launch " + intent +
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002388 ". Make sure to create a MAIN intent-filter for the corresponding activity " +
Joe Onoratof984e852010-03-25 09:47:45 -07002389 "or use the exported attribute for this activity. "
2390 + "tag="+ tag + " intent=" + intent, e);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002391 }
Michael Jurkaddd62e92011-02-16 17:49:14 -08002392 return false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002393 }
Winson Chungaafa03c2010-06-11 17:34:16 -07002394
Michael Jurka86a720e2012-05-09 11:23:23 -07002395 boolean startActivitySafely(View v, Intent intent, Object tag) {
2396 boolean success = false;
2397 try {
2398 success = startActivity(v, intent, tag);
2399 } catch (ActivityNotFoundException e) {
2400 Toast.makeText(this, R.string.activity_not_found, Toast.LENGTH_SHORT).show();
2401 Log.e(TAG, "Unable to launch. tag=" + tag + " intent=" + intent, e);
2402 }
2403 return success;
2404 }
2405
Adam Cohena9cf38f2011-05-02 15:36:58 -07002406 private void handleFolderClick(FolderIcon folderIcon) {
Adam Cohenfb91f302012-06-11 15:45:18 -07002407 final FolderInfo info = folderIcon.getFolderInfo();
Adam Cohen3c81a382011-08-31 22:25:51 -07002408 Folder openFolder = mWorkspace.getFolderForTag(info);
2409
2410 // If the folder info reports that the associated folder is open, then verify that
2411 // it is actually opened. There have been a few instances where this gets out of sync.
2412 if (info.opened && openFolder == null) {
2413 Log.d(TAG, "Folder info marked as open, but associated folder is not open. Screen: "
Adam Cohendcd297f2013-06-18 13:13:40 -07002414 + info.screenId + " (" + info.cellX + ", " + info.cellY + ")");
Adam Cohen3c81a382011-08-31 22:25:51 -07002415 info.opened = false;
2416 }
2417
Adam Cohenfb91f302012-06-11 15:45:18 -07002418 if (!info.opened && !folderIcon.getFolder().isDestroyed()) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002419 // Close any open folder
2420 closeFolder();
2421 // Open the requested folder
Adam Cohena9cf38f2011-05-02 15:36:58 -07002422 openFolder(folderIcon);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002423 } else {
2424 // Find the open folder...
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002425 int folderScreen;
2426 if (openFolder != null) {
Michael Jurka0142d492010-08-25 17:46:15 -07002427 folderScreen = mWorkspace.getPageForView(openFolder);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002428 // .. and close it
2429 closeFolder(openFolder);
Michael Jurka0142d492010-08-25 17:46:15 -07002430 if (folderScreen != mWorkspace.getCurrentPage()) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002431 // Close any folder open on the current screen
2432 closeFolder();
2433 // Pull the folder onto this screen
Adam Cohena9cf38f2011-05-02 15:36:58 -07002434 openFolder(folderIcon);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002435 }
2436 }
2437 }
2438 }
2439
Adam Cohen268c4752012-06-06 17:47:33 -07002440 /**
2441 * This method draws the FolderIcon to an ImageView and then adds and positions that ImageView
2442 * in the DragLayer in the exact absolute location of the original FolderIcon.
2443 */
2444 private void copyFolderIconToImage(FolderIcon fi) {
2445 final int width = fi.getMeasuredWidth();
2446 final int height = fi.getMeasuredHeight();
2447
2448 // Lazy load ImageView, Bitmap and Canvas
2449 if (mFolderIconImageView == null) {
2450 mFolderIconImageView = new ImageView(this);
2451 }
2452 if (mFolderIconBitmap == null || mFolderIconBitmap.getWidth() != width ||
2453 mFolderIconBitmap.getHeight() != height) {
2454 mFolderIconBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
2455 mFolderIconCanvas = new Canvas(mFolderIconBitmap);
2456 }
2457
2458 DragLayer.LayoutParams lp;
2459 if (mFolderIconImageView.getLayoutParams() instanceof DragLayer.LayoutParams) {
2460 lp = (DragLayer.LayoutParams) mFolderIconImageView.getLayoutParams();
2461 } else {
2462 lp = new DragLayer.LayoutParams(width, height);
2463 }
2464
Adam Cohen307fe232012-08-16 17:55:58 -07002465 // The layout from which the folder is being opened may be scaled, adjust the starting
2466 // view size by this scale factor.
2467 float scale = mDragLayer.getDescendantRectRelativeToSelf(fi, mRectForFolderAnimation);
Adam Cohen268c4752012-06-06 17:47:33 -07002468 lp.customPosition = true;
2469 lp.x = mRectForFolderAnimation.left;
2470 lp.y = mRectForFolderAnimation.top;
Adam Cohen307fe232012-08-16 17:55:58 -07002471 lp.width = (int) (scale * width);
2472 lp.height = (int) (scale * height);
Adam Cohen268c4752012-06-06 17:47:33 -07002473
2474 mFolderIconCanvas.drawColor(0, PorterDuff.Mode.CLEAR);
2475 fi.draw(mFolderIconCanvas);
2476 mFolderIconImageView.setImageBitmap(mFolderIconBitmap);
Adam Cohenfb91f302012-06-11 15:45:18 -07002477 if (fi.getFolder() != null) {
2478 mFolderIconImageView.setPivotX(fi.getFolder().getPivotXForIconAnimation());
2479 mFolderIconImageView.setPivotY(fi.getFolder().getPivotYForIconAnimation());
Adam Cohen8ec23032012-06-08 14:46:22 -07002480 }
Adam Cohen268c4752012-06-06 17:47:33 -07002481 // Just in case this image view is still in the drag layer from a previous animation,
2482 // we remove it and re-add it.
2483 if (mDragLayer.indexOfChild(mFolderIconImageView) != -1) {
2484 mDragLayer.removeView(mFolderIconImageView);
2485 }
2486 mDragLayer.addView(mFolderIconImageView, lp);
Adam Cohenfb91f302012-06-11 15:45:18 -07002487 if (fi.getFolder() != null) {
2488 fi.getFolder().bringToFront();
Adam Cohen8ec23032012-06-08 14:46:22 -07002489 }
Adam Cohen268c4752012-06-06 17:47:33 -07002490 }
2491
Adam Cohen2801caf2011-05-13 20:57:39 -07002492 private void growAndFadeOutFolderIcon(FolderIcon fi) {
Adam Cohen9932a9b2011-08-02 22:14:07 -07002493 if (fi == null) return;
Adam Cohen2801caf2011-05-13 20:57:39 -07002494 PropertyValuesHolder alpha = PropertyValuesHolder.ofFloat("alpha", 0);
2495 PropertyValuesHolder scaleX = PropertyValuesHolder.ofFloat("scaleX", 1.5f);
2496 PropertyValuesHolder scaleY = PropertyValuesHolder.ofFloat("scaleY", 1.5f);
2497
Adam Cohenc51934b2011-07-26 21:07:43 -07002498 FolderInfo info = (FolderInfo) fi.getTag();
2499 if (info.container == LauncherSettings.Favorites.CONTAINER_HOTSEAT) {
2500 CellLayout cl = (CellLayout) fi.getParent().getParent();
Winson Chunge50adee2011-08-11 16:12:00 -07002501 CellLayout.LayoutParams lp = (CellLayout.LayoutParams) fi.getLayoutParams();
2502 cl.setFolderLeaveBehindCell(lp.cellX, lp.cellY);
Adam Cohenc51934b2011-07-26 21:07:43 -07002503 }
2504
Adam Cohen268c4752012-06-06 17:47:33 -07002505 // Push an ImageView copy of the FolderIcon into the DragLayer and hide the original
2506 copyFolderIconToImage(fi);
2507 fi.setVisibility(View.INVISIBLE);
2508
Michael Jurka2ecf9952012-06-18 12:52:28 -07002509 ObjectAnimator oa = LauncherAnimUtils.ofPropertyValuesHolder(mFolderIconImageView, alpha,
Adam Cohen268c4752012-06-06 17:47:33 -07002510 scaleX, scaleY);
Adam Cohen2801caf2011-05-13 20:57:39 -07002511 oa.setDuration(getResources().getInteger(R.integer.config_folderAnimDuration));
2512 oa.start();
2513 }
2514
Adam Cohen268c4752012-06-06 17:47:33 -07002515 private void shrinkAndFadeInFolderIcon(final FolderIcon fi) {
Adam Cohen9932a9b2011-08-02 22:14:07 -07002516 if (fi == null) return;
Adam Cohen2801caf2011-05-13 20:57:39 -07002517 PropertyValuesHolder alpha = PropertyValuesHolder.ofFloat("alpha", 1.0f);
2518 PropertyValuesHolder scaleX = PropertyValuesHolder.ofFloat("scaleX", 1.0f);
2519 PropertyValuesHolder scaleY = PropertyValuesHolder.ofFloat("scaleY", 1.0f);
2520
Adam Cohen268c4752012-06-06 17:47:33 -07002521 final CellLayout cl = (CellLayout) fi.getParent().getParent();
Adam Cohenc51934b2011-07-26 21:07:43 -07002522
Adam Cohen268c4752012-06-06 17:47:33 -07002523 // We remove and re-draw the FolderIcon in-case it has changed
2524 mDragLayer.removeView(mFolderIconImageView);
2525 copyFolderIconToImage(fi);
Michael Jurka2ecf9952012-06-18 12:52:28 -07002526 ObjectAnimator oa = LauncherAnimUtils.ofPropertyValuesHolder(mFolderIconImageView, alpha,
Adam Cohen268c4752012-06-06 17:47:33 -07002527 scaleX, scaleY);
Adam Cohen2801caf2011-05-13 20:57:39 -07002528 oa.setDuration(getResources().getInteger(R.integer.config_folderAnimDuration));
Adam Cohenc51934b2011-07-26 21:07:43 -07002529 oa.addListener(new AnimatorListenerAdapter() {
2530 @Override
2531 public void onAnimationEnd(Animator animation) {
Adam Cohen268c4752012-06-06 17:47:33 -07002532 if (cl != null) {
2533 cl.clearFolderLeaveBehind();
2534 // Remove the ImageView copy of the FolderIcon and make the original visible.
2535 mDragLayer.removeView(mFolderIconImageView);
2536 fi.setVisibility(View.VISIBLE);
Adam Cohenc51934b2011-07-26 21:07:43 -07002537 }
2538 }
2539 });
Adam Cohen2801caf2011-05-13 20:57:39 -07002540 oa.start();
2541 }
2542
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002543 /**
Michael Jurka774bd372010-10-22 13:40:50 -07002544 * Opens the user folder described by the specified tag. The opening of the folder
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002545 * is animated relative to the specified View. If the View is null, no animation
2546 * is played.
2547 *
2548 * @param folderInfo The FolderInfo describing the folder to open.
2549 */
Adam Cohena9cf38f2011-05-02 15:36:58 -07002550 public void openFolder(FolderIcon folderIcon) {
Adam Cohenfb91f302012-06-11 15:45:18 -07002551 Folder folder = folderIcon.getFolder();
Adam Cohena9cf38f2011-05-02 15:36:58 -07002552 FolderInfo info = folder.mInfo;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002553
Adam Cohena9cf38f2011-05-02 15:36:58 -07002554 info.opened = true;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002555
Adam Cohen4554ee12011-08-03 16:13:21 -07002556 // Just verify that the folder hasn't already been added to the DragLayer.
2557 // There was a one-off crash where the folder had a parent already.
2558 if (folder.getParent() == null) {
2559 mDragLayer.addView(folder);
2560 mDragController.addDropTarget((DropTarget) folder);
2561 } else {
2562 Log.w(TAG, "Opening folder (" + folder + ") which already has a parent (" +
2563 folder.getParent() + ").");
2564 }
Adam Cohena9cf38f2011-05-02 15:36:58 -07002565 folder.animateOpen();
Adam Cohen268c4752012-06-06 17:47:33 -07002566 growAndFadeOutFolderIcon(folderIcon);
Winson Chung83ca4802013-04-12 15:10:52 -07002567
2568 // Notify the accessibility manager that this folder "window" has appeared and occluded
2569 // the workspace items
2570 folder.sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
2571 getDragLayer().sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED);
Adam Cohen4554ee12011-08-03 16:13:21 -07002572 }
2573
2574 public void closeFolder() {
2575 Folder folder = mWorkspace.getOpenFolder();
2576 if (folder != null) {
Adam Cohenac56cff2011-09-28 20:45:37 -07002577 if (folder.isEditingName()) {
2578 folder.dismissEditingName();
2579 }
Adam Cohen4554ee12011-08-03 16:13:21 -07002580 closeFolder(folder);
Winson Chung7d7541e2011-09-16 20:14:36 -07002581
2582 // Dismiss the folder cling
2583 dismissFolderCling(null);
Adam Cohen4554ee12011-08-03 16:13:21 -07002584 }
2585 }
2586
2587 void closeFolder(Folder folder) {
2588 folder.getInfo().opened = false;
2589
2590 ViewGroup parent = (ViewGroup) folder.getParent().getParent();
2591 if (parent != null) {
2592 FolderIcon fi = (FolderIcon) mWorkspace.getViewForTag(folder.mInfo);
2593 shrinkAndFadeInFolderIcon(fi);
2594 }
2595 folder.animateClosed();
Winson Chung83ca4802013-04-12 15:10:52 -07002596
2597 // Notify the accessibility manager that this folder "window" has disappeard and no
2598 // longer occludeds the workspace items
2599 getDragLayer().sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002600 }
2601
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002602 public boolean onLongClick(View v) {
Winson Chung36a62fe2012-05-06 18:04:42 -07002603 if (!isDraggingEnabled()) return false;
2604 if (isWorkspaceLocked()) return false;
2605 if (mState != State.WORKSPACE) return false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002606
Adam Cohen1697b792013-09-17 19:08:21 -07002607 if (v instanceof Workspace) {
2608 if (!mWorkspace.isInOverviewMode()) {
Adam Cohen93c97562013-09-26 13:48:01 -07002609 if (mWorkspace.enterOverviewMode()) {
2610 mWorkspace.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS,
2611 HapticFeedbackConstants.FLAG_IGNORE_VIEW_SETTING);
2612 return true;
2613 } else {
2614 return false;
2615 }
Adam Cohen1697b792013-09-17 19:08:21 -07002616 }
Adam Cohen1697b792013-09-17 19:08:21 -07002617 }
2618
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002619 if (!(v instanceof CellLayout)) {
Michael Jurka8c920dd2011-01-20 14:16:56 -08002620 v = (View) v.getParent().getParent();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002621 }
2622
Michael Jurka0280c3b2010-09-17 15:00:07 -07002623 resetAddInfo();
2624 CellLayout.CellInfo longClickCellInfo = (CellLayout.CellInfo) v.getTag();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002625 // This happens when long clicking an item with the dpad/trackball
Adam Cohenfaea1f82011-07-21 16:23:57 -07002626 if (longClickCellInfo == null) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002627 return true;
2628 }
2629
Winson Chung3d503fb2011-07-13 17:25:49 -07002630 // The hotseat touch handling does not go through Workspace, and we always allow long press
2631 // on hotseat items.
Michael Jurka0280c3b2010-09-17 15:00:07 -07002632 final View itemUnderLongClick = longClickCellInfo.cell;
Winson Chung3d503fb2011-07-13 17:25:49 -07002633 boolean allowLongPress = isHotseatLayout(v) || mWorkspace.allowLongPress();
2634 if (allowLongPress && !mDragController.isDragging()) {
Michael Jurka0280c3b2010-09-17 15:00:07 -07002635 if (itemUnderLongClick == null) {
Adam Cohend3ecce92013-09-16 14:58:00 -07002636 // User long pressed on empty space
2637 mWorkspace.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS,
2638 HapticFeedbackConstants.FLAG_IGNORE_VIEW_SETTING);
2639 // Disabling reordering until we sort out some issues.
2640 if (mWorkspace.isInOverviewMode()) {
2641 mWorkspace.startReordering(v);
2642 } else {
2643 mWorkspace.enterOverviewMode();
Adam Cohendedbd962013-07-11 14:21:49 -07002644 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002645 } else {
Michael Jurka0280c3b2010-09-17 15:00:07 -07002646 if (!(itemUnderLongClick instanceof Folder)) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002647 // User long pressed on an item
Michael Jurka0280c3b2010-09-17 15:00:07 -07002648 mWorkspace.startDrag(longClickCellInfo);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002649 }
2650 }
2651 }
2652 return true;
2653 }
2654
Winson Chung3d503fb2011-07-13 17:25:49 -07002655 boolean isHotseatLayout(View layout) {
2656 return mHotseat != null && layout != null &&
2657 (layout instanceof CellLayout) && (layout == mHotseat.getLayout());
2658 }
2659 Hotseat getHotseat() {
2660 return mHotseat;
Romain Guy1fbc1c82009-11-09 20:43:08 -08002661 }
Adam Cohenf358a4b2013-07-23 16:47:31 -07002662 View getOverviewPanel() {
2663 return mOverviewPanel;
2664 }
Adam Cohenebea84d2011-11-09 17:20:41 -08002665 SearchDropTargetBar getSearchBar() {
2666 return mSearchDropTargetBar;
2667 }
Romain Guy1fbc1c82009-11-09 20:43:08 -08002668
Winson Chung3d503fb2011-07-13 17:25:49 -07002669 /**
2670 * Returns the CellLayout of the specified container at the specified screen.
2671 */
Adam Cohendcd297f2013-06-18 13:13:40 -07002672 CellLayout getCellLayout(long container, long screenId) {
Winson Chung3d503fb2011-07-13 17:25:49 -07002673 if (container == LauncherSettings.Favorites.CONTAINER_HOTSEAT) {
2674 if (mHotseat != null) {
2675 return mHotseat.getLayout();
2676 } else {
2677 return null;
Romain Guye6b8e2f2009-11-10 11:56:55 -08002678 }
Winson Chung3d503fb2011-07-13 17:25:49 -07002679 } else {
Adam Cohendcd297f2013-06-18 13:13:40 -07002680 return (CellLayout) mWorkspace.getScreenWithId(screenId);
Romain Guya6abce82009-11-10 02:54:41 -08002681 }
2682 }
2683
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002684 Workspace getWorkspace() {
2685 return mWorkspace;
2686 }
2687
Daniel Sandler843e8602010-06-07 14:59:01 -04002688 public boolean isAllAppsVisible() {
Winson Chungc93e5ae2012-07-23 20:48:26 -07002689 return (mState == State.APPS_CUSTOMIZE) || (mOnResumeState == State.APPS_CUSTOMIZE);
Joe Onoratofb0ca672009-09-14 17:55:46 -04002690 }
2691
Patrick Dubroy6b509c12010-08-23 15:08:16 -07002692 /**
2693 * Helper method for the cameraZoomIn/cameraZoomOut animations
2694 * @param view The view being animated
Patrick Dubroy6b509c12010-08-23 15:08:16 -07002695 * @param scaleFactor The scale factor used for the zoom
2696 */
Michael Jurkab3e22d92011-10-31 15:58:33 -07002697 private void setPivotsForZoom(View view, float scaleFactor) {
Patrick Dubroy6b509c12010-08-23 15:08:16 -07002698 view.setPivotX(view.getWidth() / 2.0f);
Adam Cohen7777d962011-08-18 18:58:38 -07002699 view.setPivotY(view.getHeight() / 2.0f);
Patrick Dubroy6b509c12010-08-23 15:08:16 -07002700 }
Daniel Sandlerc351eb82010-03-03 15:05:19 -05002701
Craig Mautner360310b2012-10-26 15:13:08 -07002702 private void setWorkspaceBackground(boolean workspace) {
2703 mLauncherView.setBackground(workspace ?
Michael Jurka496fefb2013-05-06 15:39:11 +02002704 mWorkspaceBackgroundDrawable : null);
Craig Mautner360310b2012-10-26 15:13:08 -07002705 }
2706
Dianne Hackbornbb003a52011-08-30 14:40:07 -07002707 void updateWallpaperVisibility(boolean visible) {
2708 int wpflags = visible ? WindowManager.LayoutParams.FLAG_SHOW_WALLPAPER : 0;
2709 int curflags = getWindow().getAttributes().flags
2710 & WindowManager.LayoutParams.FLAG_SHOW_WALLPAPER;
2711 if (wpflags != curflags) {
2712 getWindow().setFlags(wpflags, WindowManager.LayoutParams.FLAG_SHOW_WALLPAPER);
2713 }
Craig Mautner360310b2012-10-26 15:13:08 -07002714 setWorkspaceBackground(visible);
Dianne Hackbornbb003a52011-08-30 14:40:07 -07002715 }
2716
Michael Jurkaa35e35a2012-04-26 15:04:28 -07002717 private void dispatchOnLauncherTransitionPrepare(View v, boolean animated, boolean toWorkspace) {
2718 if (v instanceof LauncherTransitionable) {
2719 ((LauncherTransitionable) v).onLauncherTransitionPrepare(this, animated, toWorkspace);
2720 }
2721 }
2722
Michael Jurkabed61d22012-02-14 22:51:29 -08002723 private void dispatchOnLauncherTransitionStart(View v, boolean animated, boolean toWorkspace) {
2724 if (v instanceof LauncherTransitionable) {
2725 ((LauncherTransitionable) v).onLauncherTransitionStart(this, animated, toWorkspace);
2726 }
Winson Chung70442722012-02-10 15:43:22 -08002727
2728 // Update the workspace transition step as well
2729 dispatchOnLauncherTransitionStep(v, 0f);
2730 }
2731
2732 private void dispatchOnLauncherTransitionStep(View v, float t) {
2733 if (v instanceof LauncherTransitionable) {
2734 ((LauncherTransitionable) v).onLauncherTransitionStep(this, t);
2735 }
Michael Jurkabed61d22012-02-14 22:51:29 -08002736 }
2737
2738 private void dispatchOnLauncherTransitionEnd(View v, boolean animated, boolean toWorkspace) {
2739 if (v instanceof LauncherTransitionable) {
2740 ((LauncherTransitionable) v).onLauncherTransitionEnd(this, animated, toWorkspace);
2741 }
Winson Chung70442722012-02-10 15:43:22 -08002742
2743 // Update the workspace transition step as well
2744 dispatchOnLauncherTransitionStep(v, 1f);
Michael Jurkabed61d22012-02-14 22:51:29 -08002745 }
2746
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07002747 /**
Michael Jurkab3e22d92011-10-31 15:58:33 -07002748 * Things to test when changing the following seven functions.
2749 * - Home from workspace
2750 * - from center screen
2751 * - from other screens
2752 * - Home from all apps
2753 * - from center screen
2754 * - from other screens
2755 * - Back from all apps
2756 * - from center screen
2757 * - from other screens
2758 * - Launch app from workspace and quit
2759 * - with back
2760 * - with home
2761 * - Launch app from all apps and quit
2762 * - with back
2763 * - with home
2764 * - Go to a screen that's not the default, then all
2765 * apps, and launch and app, and go back
2766 * - with back
2767 * -with home
2768 * - On workspace, long press power and go back
2769 * - with back
2770 * - with home
2771 * - On all apps, long press power and go back
2772 * - with back
2773 * - with home
2774 * - On workspace, power off
2775 * - On all apps, power off
2776 * - Launch an app and turn off the screen while in that app
2777 * - Go back with home key
2778 * - Go back with back key TODO: make this not go to workspace
2779 * - From all apps
2780 * - From workspace
2781 * - Enter and exit car mode (becuase it causes an extra configuration changed)
2782 * - From all apps
2783 * - From the center workspace
2784 * - From another workspace
2785 */
2786
2787 /**
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07002788 * Zoom the camera out from the workspace to reveal 'toView'.
2789 * Assumes that the view to show is anchored at either the very top or very bottom
2790 * of the screen.
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07002791 */
Michael Jurkabed61d22012-02-14 22:51:29 -08002792 private void showAppsCustomizeHelper(final boolean animated, final boolean springLoaded) {
Winson Chungc58497e2013-09-03 17:48:37 -07002793 AppsCustomizePagedView.ContentType contentType = mAppsCustomizeContent.getContentType();
2794 showAppsCustomizeHelper(animated, springLoaded, contentType);
2795 }
2796 private void showAppsCustomizeHelper(final boolean animated, final boolean springLoaded,
2797 final AppsCustomizePagedView.ContentType contentType) {
Michael Jurkab3e22d92011-10-31 15:58:33 -07002798 if (mStateAnimation != null) {
Michael Jurkaf1ad6082013-03-13 12:55:46 +01002799 mStateAnimation.setDuration(0);
Michael Jurkab3e22d92011-10-31 15:58:33 -07002800 mStateAnimation.cancel();
2801 mStateAnimation = null;
2802 }
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07002803 final Resources res = getResources();
Adam Cohenf16e5712011-01-13 13:31:45 -08002804
Winson Chungf0ea4d32011-06-06 14:27:16 -07002805 final int duration = res.getInteger(R.integer.config_appsCustomizeZoomInTime);
2806 final int fadeDuration = res.getInteger(R.integer.config_appsCustomizeFadeInTime);
2807 final float scale = (float) res.getInteger(R.integer.config_appsCustomizeZoomScaleFactor);
Michael Jurkabed61d22012-02-14 22:51:29 -08002808 final View fromView = mWorkspace;
Michael Jurkaa35e35a2012-04-26 15:04:28 -07002809 final AppsCustomizeTabHost toView = mAppsCustomizeTabHost;
Adam Cohencff6af82011-09-13 14:51:53 -07002810 final int startDelay =
2811 res.getInteger(R.integer.config_workspaceAppsCustomizeAnimationStagger);
Patrick Dubroy558654c2010-07-23 16:48:11 -07002812
Michael Jurkab3e22d92011-10-31 15:58:33 -07002813 setPivotsForZoom(toView, scale);
Patrick Dubroy6b509c12010-08-23 15:08:16 -07002814
Michael Jurkad74c9842011-07-10 12:44:21 -07002815 // Shrink workspaces away if going to AppsCustomize from workspace
Michael Jurka2a4b1a82011-12-07 14:00:02 -08002816 Animator workspaceAnim =
2817 mWorkspace.getChangeStateAnimation(Workspace.State.SMALL, animated);
Winson Chungc58497e2013-09-03 17:48:37 -07002818 if (!AppsCustomizePagedView.DISABLE_ALL_APPS) {
2819 // Set the content type for the all apps space
2820 mAppsCustomizeTabHost.setContentTypeImmediate(contentType);
2821 }
Patrick Dubroydf7c3a72010-08-26 17:52:56 -07002822
2823 if (animated) {
Michael Jurka7407d2a2011-12-12 21:48:38 -08002824 toView.setScaleX(scale);
2825 toView.setScaleY(scale);
2826 final LauncherViewPropertyAnimator scaleAnim = new LauncherViewPropertyAnimator(toView);
2827 scaleAnim.
2828 scaleX(1f).scaleY(1f).
2829 setDuration(duration).
2830 setInterpolator(new Workspace.ZoomOutInterpolator());
Adam Cohen61033d32010-11-15 18:29:44 -08002831
Winson Chungf0ea4d32011-06-06 14:27:16 -07002832 toView.setVisibility(View.VISIBLE);
Adam Cohenc00f0b92011-12-06 19:45:06 -08002833 toView.setAlpha(0f);
Michael Jurkaf1ad6082013-03-13 12:55:46 +01002834 final ObjectAnimator alphaAnim = LauncherAnimUtils
Michael Jurka159b4cc2012-01-17 03:00:35 -08002835 .ofFloat(toView, "alpha", 0f, 1f)
2836 .setDuration(fadeDuration);
Winson Chungf0ea4d32011-06-06 14:27:16 -07002837 alphaAnim.setInterpolator(new DecelerateInterpolator(1.5f));
Winson Chung70442722012-02-10 15:43:22 -08002838 alphaAnim.addUpdateListener(new AnimatorUpdateListener() {
2839 @Override
2840 public void onAnimationUpdate(ValueAnimator animation) {
Michael Jurka059798a2012-09-04 09:20:16 -07002841 if (animation == null) {
2842 throw new RuntimeException("animation is null");
2843 }
Winson Chung70442722012-02-10 15:43:22 -08002844 float t = (Float) animation.getAnimatedValue();
2845 dispatchOnLauncherTransitionStep(fromView, t);
2846 dispatchOnLauncherTransitionStep(toView, t);
2847 }
2848 });
Adam Cohenf16e5712011-01-13 13:31:45 -08002849
Michael Jurka2a4b1a82011-12-07 14:00:02 -08002850 // toView should appear right at the end of the workspace shrink
2851 // animation
Michael Jurka2ecf9952012-06-18 12:52:28 -07002852 mStateAnimation = LauncherAnimUtils.createAnimatorSet();
Michael Jurka2a4b1a82011-12-07 14:00:02 -08002853 mStateAnimation.play(scaleAnim).after(startDelay);
Michael Jurka7407d2a2011-12-12 21:48:38 -08002854 mStateAnimation.play(alphaAnim).after(startDelay);
Michael Jurka2a4b1a82011-12-07 14:00:02 -08002855
2856 mStateAnimation.addListener(new AnimatorListenerAdapter() {
Gilles Debunnedd6c9922010-10-25 11:23:41 -07002857 @Override
Chet Haaseb1254a62010-09-07 13:35:00 -07002858 public void onAnimationStart(Animator animation) {
Patrick Dubroydf7c3a72010-08-26 17:52:56 -07002859 // Prepare the position
2860 toView.setTranslationX(0.0f);
2861 toView.setTranslationY(0.0f);
2862 toView.setVisibility(View.VISIBLE);
Winson Chung785d2eb2011-04-14 16:08:02 -07002863 toView.bringToFront();
Patrick Dubroydf7c3a72010-08-26 17:52:56 -07002864 }
Michael Jurka3c4c20f2010-10-28 15:36:06 -07002865 @Override
Michael Jurka8edd75c2010-12-17 20:15:06 -08002866 public void onAnimationEnd(Animator animation) {
Michael Jurkabed61d22012-02-14 22:51:29 -08002867 dispatchOnLauncherTransitionEnd(fromView, animated, false);
2868 dispatchOnLauncherTransitionEnd(toView, animated, false);
Winson Chung32174c82011-07-19 15:47:55 -07002869
Winson Chungc7d2b602012-05-16 17:02:20 -07002870 // Hide the search bar
Winson Chungadf0c182012-08-23 14:59:07 -07002871 if (mSearchDropTargetBar != null) {
2872 mSearchDropTargetBar.hideSearchBar(false);
2873 }
Adam Cohenf4ddea32011-09-12 13:46:42 -07002874 }
Patrick Dubroydf7c3a72010-08-26 17:52:56 -07002875 });
2876
Michael Jurka2a4b1a82011-12-07 14:00:02 -08002877 if (workspaceAnim != null) {
2878 mStateAnimation.play(workspaceAnim);
2879 }
Michael Jurka1899a362011-11-03 13:50:45 -07002880
2881 boolean delayAnim = false;
Michael Jurka2a4b1a82011-12-07 14:00:02 -08002882
Michael Jurkaa35e35a2012-04-26 15:04:28 -07002883 dispatchOnLauncherTransitionPrepare(fromView, animated, false);
2884 dispatchOnLauncherTransitionPrepare(toView, animated, false);
Michael Jurka2a4b1a82011-12-07 14:00:02 -08002885
2886 // If any of the objects being animated haven't been measured/laid out
2887 // yet, delay the animation until we get a layout pass
Michael Jurkabed61d22012-02-14 22:51:29 -08002888 if ((((LauncherTransitionable) toView).getContent().getMeasuredWidth() == 0) ||
Michael Jurka2a4b1a82011-12-07 14:00:02 -08002889 (mWorkspace.getMeasuredWidth() == 0) ||
2890 (toView.getMeasuredWidth() == 0)) {
Michael Jurka2a4b1a82011-12-07 14:00:02 -08002891 delayAnim = true;
Michael Jurka1899a362011-11-03 13:50:45 -07002892 }
Michael Jurka2a4b1a82011-12-07 14:00:02 -08002893
Michael Jurka3dcd79e2012-05-31 07:50:33 -07002894 final AnimatorSet stateAnimation = mStateAnimation;
2895 final Runnable startAnimRunnable = new Runnable() {
2896 public void run() {
2897 // Check that mStateAnimation hasn't changed while
2898 // we waited for a layout/draw pass
2899 if (mStateAnimation != stateAnimation)
2900 return;
2901 setPivotsForZoom(toView, scale);
2902 dispatchOnLauncherTransitionStart(fromView, animated, false);
2903 dispatchOnLauncherTransitionStart(toView, animated, false);
Michael Jurkaf1ad6082013-03-13 12:55:46 +01002904 LauncherAnimUtils.startAnimationAfterNextDraw(mStateAnimation, toView);
Michael Jurka3dcd79e2012-05-31 07:50:33 -07002905 }
2906 };
Michael Jurka2a4b1a82011-12-07 14:00:02 -08002907 if (delayAnim) {
Michael Jurkaf1ad6082013-03-13 12:55:46 +01002908 final ViewTreeObserver observer = toView.getViewTreeObserver();
2909 observer.addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
2910 public void onGlobalLayout() {
2911 startAnimRunnable.run();
2912 toView.getViewTreeObserver().removeOnGlobalLayoutListener(this);
2913 }
2914 });
Michael Jurka2a4b1a82011-12-07 14:00:02 -08002915 } else {
Michael Jurka3dcd79e2012-05-31 07:50:33 -07002916 startAnimRunnable.run();
Michael Jurka1899a362011-11-03 13:50:45 -07002917 }
Patrick Dubroydf7c3a72010-08-26 17:52:56 -07002918 } else {
2919 toView.setTranslationX(0.0f);
2920 toView.setTranslationY(0.0f);
2921 toView.setScaleX(1.0f);
2922 toView.setScaleY(1.0f);
2923 toView.setVisibility(View.VISIBLE);
Winson Chung785d2eb2011-04-14 16:08:02 -07002924 toView.bringToFront();
Winson Chung3ac74c52011-06-30 17:39:37 -07002925
Daniel Sandlere4f98912013-06-25 15:13:26 -04002926 if (!springLoaded && !LauncherAppState.getInstance().isScreenLarge()) {
Winson Chungc7d2b602012-05-16 17:02:20 -07002927 // Hide the search bar
Winson Chungadf0c182012-08-23 14:59:07 -07002928 if (mSearchDropTargetBar != null) {
2929 mSearchDropTargetBar.hideSearchBar(false);
2930 }
Michael Jurkaabded662011-03-04 12:06:57 -08002931 }
Michael Jurkaa35e35a2012-04-26 15:04:28 -07002932 dispatchOnLauncherTransitionPrepare(fromView, animated, false);
Michael Jurkabed61d22012-02-14 22:51:29 -08002933 dispatchOnLauncherTransitionStart(fromView, animated, false);
2934 dispatchOnLauncherTransitionEnd(fromView, animated, false);
Michael Jurkaa35e35a2012-04-26 15:04:28 -07002935 dispatchOnLauncherTransitionPrepare(toView, animated, false);
Michael Jurkabed61d22012-02-14 22:51:29 -08002936 dispatchOnLauncherTransitionStart(toView, animated, false);
2937 dispatchOnLauncherTransitionEnd(toView, animated, false);
Patrick Dubroydf7c3a72010-08-26 17:52:56 -07002938 }
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07002939 }
2940
2941 /**
2942 * Zoom the camera back into the workspace, hiding 'fromView'.
Michael Jurkab3e22d92011-10-31 15:58:33 -07002943 * This is the opposite of showAppsCustomizeHelper.
Patrick Dubroy6b509c12010-08-23 15:08:16 -07002944 * @param animated If true, the transition will be animated.
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07002945 */
Adam Cohened66b2b2012-01-23 17:28:51 -08002946 private void hideAppsCustomizeHelper(State toState, final boolean animated,
2947 final boolean springLoaded, final Runnable onCompleteRunnable) {
Michael Jurkabed61d22012-02-14 22:51:29 -08002948
Michael Jurkab3e22d92011-10-31 15:58:33 -07002949 if (mStateAnimation != null) {
Michael Jurkaf1ad6082013-03-13 12:55:46 +01002950 mStateAnimation.setDuration(0);
Michael Jurkab3e22d92011-10-31 15:58:33 -07002951 mStateAnimation.cancel();
2952 mStateAnimation = null;
2953 }
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07002954 Resources res = getResources();
Adam Cohenf16e5712011-01-13 13:31:45 -08002955
Winson Chungf0ea4d32011-06-06 14:27:16 -07002956 final int duration = res.getInteger(R.integer.config_appsCustomizeZoomOutTime);
Michael Jurka159b4cc2012-01-17 03:00:35 -08002957 final int fadeOutDuration =
2958 res.getInteger(R.integer.config_appsCustomizeFadeOutTime);
Winson Chungf0ea4d32011-06-06 14:27:16 -07002959 final float scaleFactor = (float)
2960 res.getInteger(R.integer.config_appsCustomizeZoomScaleFactor);
2961 final View fromView = mAppsCustomizeTabHost;
Michael Jurkabed61d22012-02-14 22:51:29 -08002962 final View toView = mWorkspace;
Michael Jurka2a4b1a82011-12-07 14:00:02 -08002963 Animator workspaceAnim = null;
Michael Jurka2a4b1a82011-12-07 14:00:02 -08002964 if (toState == State.WORKSPACE) {
2965 int stagger = res.getInteger(R.integer.config_appsCustomizeWorkspaceAnimationStagger);
2966 workspaceAnim = mWorkspace.getChangeStateAnimation(
Adam Cohenf358a4b2013-07-23 16:47:31 -07002967 Workspace.State.NORMAL, animated, stagger, -1);
Michael Jurka2a4b1a82011-12-07 14:00:02 -08002968 } else if (toState == State.APPS_CUSTOMIZE_SPRING_LOADED) {
2969 workspaceAnim = mWorkspace.getChangeStateAnimation(
2970 Workspace.State.SPRING_LOADED, animated);
2971 }
Patrick Dubroy2b9ff372010-09-07 17:49:27 -07002972
Michael Jurkab3e22d92011-10-31 15:58:33 -07002973 setPivotsForZoom(fromView, scaleFactor);
Winson Chung4afe9b32011-07-27 17:46:20 -07002974 showHotseat(animated);
Patrick Dubroydf7c3a72010-08-26 17:52:56 -07002975 if (animated) {
Michael Jurka159b4cc2012-01-17 03:00:35 -08002976 final LauncherViewPropertyAnimator scaleAnim =
2977 new LauncherViewPropertyAnimator(fromView);
2978 scaleAnim.
2979 scaleX(scaleFactor).scaleY(scaleFactor).
2980 setDuration(duration).
2981 setInterpolator(new Workspace.ZoomInInterpolator());
2982
Michael Jurkaf1ad6082013-03-13 12:55:46 +01002983 final ObjectAnimator alphaAnim = LauncherAnimUtils
Michael Jurka159b4cc2012-01-17 03:00:35 -08002984 .ofFloat(fromView, "alpha", 1f, 0f)
2985 .setDuration(fadeOutDuration);
Adam Cohencff6af82011-09-13 14:51:53 -07002986 alphaAnim.setInterpolator(new AccelerateDecelerateInterpolator());
Winson Chung70442722012-02-10 15:43:22 -08002987 alphaAnim.addUpdateListener(new AnimatorUpdateListener() {
2988 @Override
2989 public void onAnimationUpdate(ValueAnimator animation) {
2990 float t = 1f - (Float) animation.getAnimatedValue();
2991 dispatchOnLauncherTransitionStep(fromView, t);
2992 dispatchOnLauncherTransitionStep(toView, t);
2993 }
2994 });
Michael Jurka159b4cc2012-01-17 03:00:35 -08002995
Michael Jurka2ecf9952012-06-18 12:52:28 -07002996 mStateAnimation = LauncherAnimUtils.createAnimatorSet();
Michael Jurkabed61d22012-02-14 22:51:29 -08002997
Michael Jurkaa35e35a2012-04-26 15:04:28 -07002998 dispatchOnLauncherTransitionPrepare(fromView, animated, true);
2999 dispatchOnLauncherTransitionPrepare(toView, animated, true);
Chet Haasebc2f0822012-10-26 17:59:53 -07003000 mAppsCustomizeContent.pauseScrolling();
Michael Jurkabed61d22012-02-14 22:51:29 -08003001
3002 mStateAnimation.addListener(new AnimatorListenerAdapter() {
Gilles Debunnedd6c9922010-10-25 11:23:41 -07003003 @Override
Michael Jurka8edd75c2010-12-17 20:15:06 -08003004 public void onAnimationEnd(Animator animation) {
Patrick Dubroydf7c3a72010-08-26 17:52:56 -07003005 fromView.setVisibility(View.GONE);
Michael Jurkabed61d22012-02-14 22:51:29 -08003006 dispatchOnLauncherTransitionEnd(fromView, animated, true);
3007 dispatchOnLauncherTransitionEnd(toView, animated, true);
Adam Cohened66b2b2012-01-23 17:28:51 -08003008 if (onCompleteRunnable != null) {
3009 onCompleteRunnable.run();
3010 }
Chet Haasebc2f0822012-10-26 17:59:53 -07003011 mAppsCustomizeContent.updateCurrentPageScroll();
3012 mAppsCustomizeContent.resumeScrolling();
Patrick Dubroydf7c3a72010-08-26 17:52:56 -07003013 }
3014 });
3015
Winson Chungf0ea4d32011-06-06 14:27:16 -07003016 mStateAnimation.playTogether(scaleAnim, alphaAnim);
Michael Jurka2a4b1a82011-12-07 14:00:02 -08003017 if (workspaceAnim != null) {
3018 mStateAnimation.play(workspaceAnim);
3019 }
Michael Jurkaa35e35a2012-04-26 15:04:28 -07003020 dispatchOnLauncherTransitionStart(fromView, animated, true);
3021 dispatchOnLauncherTransitionStart(toView, animated, true);
Michael Jurkaf1ad6082013-03-13 12:55:46 +01003022 LauncherAnimUtils.startAnimationAfterNextDraw(mStateAnimation, toView);
Patrick Dubroydf7c3a72010-08-26 17:52:56 -07003023 } else {
3024 fromView.setVisibility(View.GONE);
Michael Jurkaa35e35a2012-04-26 15:04:28 -07003025 dispatchOnLauncherTransitionPrepare(fromView, animated, true);
Michael Jurkabed61d22012-02-14 22:51:29 -08003026 dispatchOnLauncherTransitionStart(fromView, animated, true);
3027 dispatchOnLauncherTransitionEnd(fromView, animated, true);
Michael Jurkaa35e35a2012-04-26 15:04:28 -07003028 dispatchOnLauncherTransitionPrepare(toView, animated, true);
Michael Jurkabed61d22012-02-14 22:51:29 -08003029 dispatchOnLauncherTransitionStart(toView, animated, true);
3030 dispatchOnLauncherTransitionEnd(toView, animated, true);
Patrick Dubroydf7c3a72010-08-26 17:52:56 -07003031 }
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07003032 }
3033
Michael Jurkae326f182011-11-21 14:05:46 -08003034 @Override
3035 public void onTrimMemory(int level) {
3036 super.onTrimMemory(level);
Winson Chungc7450e32012-04-17 17:34:08 -07003037 if (level >= ComponentCallbacks2.TRIM_MEMORY_MODERATE) {
Michael Jurkae326f182011-11-21 14:05:46 -08003038 mAppsCustomizeTabHost.onTrimMemory();
3039 }
3040 }
3041
Michael Jurkac0e8fca2010-10-06 16:41:29 -07003042 void showWorkspace(boolean animated) {
Adam Cohened66b2b2012-01-23 17:28:51 -08003043 showWorkspace(animated, null);
3044 }
3045
3046 void showWorkspace(boolean animated, Runnable onCompleteRunnable) {
Michael Jurkab3e22d92011-10-31 15:58:33 -07003047 if (mState != State.WORKSPACE) {
Winson Chung2d75f122013-09-23 16:53:31 -07003048 boolean wasInSpringLoadedMode = (mState != State.WORKSPACE);
Michael Jurkab3e22d92011-10-31 15:58:33 -07003049 mWorkspace.setVisibility(View.VISIBLE);
Adam Cohened66b2b2012-01-23 17:28:51 -08003050 hideAppsCustomizeHelper(State.WORKSPACE, animated, false, onCompleteRunnable);
Michael Jurkab3e22d92011-10-31 15:58:33 -07003051
Winson Chungc7d2b602012-05-16 17:02:20 -07003052 // Show the search bar (only animate if we were showing the drop target bar in spring
3053 // loaded mode)
Winson Chungadf0c182012-08-23 14:59:07 -07003054 if (mSearchDropTargetBar != null) {
3055 mSearchDropTargetBar.showSearchBar(wasInSpringLoadedMode);
3056 }
Winson Chungc7d2b602012-05-16 17:02:20 -07003057
Michael Jurkab3e22d92011-10-31 15:58:33 -07003058 // Set focus to the AppsCustomize button
3059 if (mAllAppsButton != null) {
3060 mAllAppsButton.requestFocus();
3061 }
Michael Jurkac0e8fca2010-10-06 16:41:29 -07003062 }
Adam Lesinski6b879f02010-11-04 16:15:23 -07003063
Michael Jurkac0e8fca2010-10-06 16:41:29 -07003064 // Change the state *after* we've called all the transition code
3065 mState = State.WORKSPACE;
Svetoslav Ganov815ba2d2011-01-07 14:55:17 -08003066
Winson Chung5fb63472011-02-02 17:03:37 -08003067 // Resume the auto-advance of widgets
3068 mUserPresent = true;
3069 updateRunning();
3070
alanv1d4fde62012-10-17 13:15:47 -07003071 // Send an accessibility event to announce the context change
3072 getWindow().getDecorView()
3073 .sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
Bjorn Bringertc459e522013-06-07 19:36:01 +01003074
Bjorn Bringert69688aa2013-06-11 20:26:38 +01003075 onWorkspaceShown(animated);
Bjorn Bringertc459e522013-06-07 19:36:01 +01003076 }
3077
Bjorn Bringert69688aa2013-06-11 20:26:38 +01003078 public void onWorkspaceShown(boolean animated) {
Joe Onorato00acb122009-08-04 16:04:30 -04003079 }
3080
Winson Chungc58497e2013-09-03 17:48:37 -07003081 void showAllApps(boolean animated,
3082 AppsCustomizePagedView.ContentType contentType) {
Michael Jurkab3e22d92011-10-31 15:58:33 -07003083 if (mState != State.WORKSPACE) return;
3084
Winson Chungc58497e2013-09-03 17:48:37 -07003085 showAppsCustomizeHelper(animated, false, contentType);
Michael Jurkab3e22d92011-10-31 15:58:33 -07003086 mAppsCustomizeTabHost.requestFocus();
3087
Michael Jurkab3e22d92011-10-31 15:58:33 -07003088 // Change the state *after* we've called all the transition code
3089 mState = State.APPS_CUSTOMIZE;
3090
3091 // Pause the auto-advance of widgets until we are out of AllApps
3092 mUserPresent = false;
3093 updateRunning();
3094 closeFolder();
3095
3096 // Send an accessibility event to announce the context change
alanv1d4fde62012-10-17 13:15:47 -07003097 getWindow().getDecorView()
3098 .sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
Michael Jurkab3e22d92011-10-31 15:58:33 -07003099 }
3100
Adam Cohen7777d962011-08-18 18:58:38 -07003101 void enterSpringLoadedDragMode() {
Winson Chungc93e5ae2012-07-23 20:48:26 -07003102 if (isAllAppsVisible()) {
Adam Cohened66b2b2012-01-23 17:28:51 -08003103 hideAppsCustomizeHelper(State.APPS_CUSTOMIZE_SPRING_LOADED, true, true, null);
Winson Chungc07918d2011-07-01 15:35:26 -07003104 mState = State.APPS_CUSTOMIZE_SPRING_LOADED;
Winson Chungb26f3d62011-06-02 10:49:29 -07003105 }
Michael Jurkad3ef3062010-11-23 16:23:58 -08003106 }
Adam Cohen7777d962011-08-18 18:58:38 -07003107
Adam Cohened66b2b2012-01-23 17:28:51 -08003108 void exitSpringLoadedDragModeDelayed(final boolean successfulDrop, boolean extendedDelay,
3109 final Runnable onCompleteRunnable) {
Winson Chung09bfc452011-09-09 11:30:20 -07003110 if (mState != State.APPS_CUSTOMIZE_SPRING_LOADED) return;
3111
Winson Chunge7a03942011-08-05 15:05:12 -07003112 mHandler.postDelayed(new Runnable() {
Winson Chung557d6ed2011-07-08 15:34:52 -07003113 @Override
3114 public void run() {
Winson Chung6a3fd3f2011-08-02 14:03:26 -07003115 if (successfulDrop) {
Michael Jurka7bdb25a2011-08-03 15:16:44 -07003116 // Before we show workspace, hide all apps again because
3117 // exitSpringLoadedDragMode made it visible. This is a bit hacky; we should
3118 // clean up our state transition functions
3119 mAppsCustomizeTabHost.setVisibility(View.GONE);
Adam Cohened66b2b2012-01-23 17:28:51 -08003120 showWorkspace(true, onCompleteRunnable);
Adam Cohen7777d962011-08-18 18:58:38 -07003121 } else {
3122 exitSpringLoadedDragMode();
Winson Chung6a3fd3f2011-08-02 14:03:26 -07003123 }
Winson Chung557d6ed2011-07-08 15:34:52 -07003124 }
3125 }, (extendedDelay ?
3126 EXIT_SPRINGLOADED_MODE_LONG_TIMEOUT :
3127 EXIT_SPRINGLOADED_MODE_SHORT_TIMEOUT));
3128 }
Michael Jurkab3e22d92011-10-31 15:58:33 -07003129
Michael Jurkad3ef3062010-11-23 16:23:58 -08003130 void exitSpringLoadedDragMode() {
Winson Chungb26f3d62011-06-02 10:49:29 -07003131 if (mState == State.APPS_CUSTOMIZE_SPRING_LOADED) {
Michael Jurkab3e22d92011-10-31 15:58:33 -07003132 final boolean animated = true;
3133 final boolean springLoaded = true;
3134 showAppsCustomizeHelper(animated, springLoaded);
Winson Chungb26f3d62011-06-02 10:49:29 -07003135 mState = State.APPS_CUSTOMIZE;
Winson Chungf0ea4d32011-06-06 14:27:16 -07003136 }
3137 // Otherwise, we are not in spring loaded mode, so don't do anything.
3138 }
3139
Michael Jurkab3e22d92011-10-31 15:58:33 -07003140 void lockAllApps() {
3141 // TODO
3142 }
3143
3144 void unlockAllApps() {
3145 // TODO
3146 }
3147
Winson Chungf0ea4d32011-06-06 14:27:16 -07003148 /**
Winson Chung3d503fb2011-07-13 17:25:49 -07003149 * Shows the hotseat area.
Winson Chungf0ea4d32011-06-06 14:27:16 -07003150 */
Winson Chung3d503fb2011-07-13 17:25:49 -07003151 void showHotseat(boolean animated) {
Daniel Sandlere4f98912013-06-25 15:13:26 -04003152 if (!LauncherAppState.getInstance().isScreenLarge()) {
Winson Chungf0ea4d32011-06-06 14:27:16 -07003153 if (animated) {
Michael Jurka7407d2a2011-12-12 21:48:38 -08003154 if (mHotseat.getAlpha() != 1f) {
Winson Chungadf0c182012-08-23 14:59:07 -07003155 int duration = 0;
3156 if (mSearchDropTargetBar != null) {
3157 duration = mSearchDropTargetBar.getTransitionInDuration();
3158 }
Michael Jurka7407d2a2011-12-12 21:48:38 -08003159 mHotseat.animate().alpha(1f).setDuration(duration);
3160 }
Winson Chungf0ea4d32011-06-06 14:27:16 -07003161 } else {
Winson Chung3d503fb2011-07-13 17:25:49 -07003162 mHotseat.setAlpha(1f);
Winson Chungf0ea4d32011-06-06 14:27:16 -07003163 }
3164 }
3165 }
3166
3167 /**
Winson Chung3d503fb2011-07-13 17:25:49 -07003168 * Hides the hotseat area.
Winson Chungf0ea4d32011-06-06 14:27:16 -07003169 */
Winson Chung3d503fb2011-07-13 17:25:49 -07003170 void hideHotseat(boolean animated) {
Daniel Sandlere4f98912013-06-25 15:13:26 -04003171 if (!LauncherAppState.getInstance().isScreenLarge()) {
Winson Chungf0ea4d32011-06-06 14:27:16 -07003172 if (animated) {
Michael Jurka7407d2a2011-12-12 21:48:38 -08003173 if (mHotseat.getAlpha() != 0f) {
Winson Chungadf0c182012-08-23 14:59:07 -07003174 int duration = 0;
3175 if (mSearchDropTargetBar != null) {
3176 duration = mSearchDropTargetBar.getTransitionOutDuration();
3177 }
Michael Jurka7407d2a2011-12-12 21:48:38 -08003178 mHotseat.animate().alpha(0f).setDuration(duration);
3179 }
Winson Chungf0ea4d32011-06-06 14:27:16 -07003180 } else {
Winson Chung3d503fb2011-07-13 17:25:49 -07003181 mHotseat.setAlpha(0f);
Winson Chungf0ea4d32011-06-06 14:27:16 -07003182 }
Winson Chungb26f3d62011-06-02 10:49:29 -07003183 }
Michael Jurkad3ef3062010-11-23 16:23:58 -08003184 }
3185
Patrick Dubroy5f445422011-02-18 14:35:21 -08003186 /**
3187 * Add an item from all apps or customize onto the given workspace screen.
3188 * If layout is null, add to the current screen.
3189 */
3190 void addExternalItemToScreen(ItemInfo itemInfo, final CellLayout layout) {
Michael Jurka6b4b25d2010-10-20 18:19:45 -07003191 if (!mWorkspace.addExternalItemToScreen(itemInfo, layout)) {
Winson Chung93eef082012-03-23 15:59:27 -07003192 showOutOfSpaceMessage(isHotseatLayout(layout));
Michael Jurka213d9632010-07-28 11:29:25 -07003193 }
Michael Jurka6b4b25d2010-10-20 18:19:45 -07003194 }
Patrick Dubroy2b9ff372010-09-07 17:49:27 -07003195
Winson Chungdff8ebb2011-09-08 17:25:31 -07003196 /** Maps the current orientation to an index for referencing orientation correct global icons */
3197 private int getCurrentOrientationIndexForGlobalIcons() {
3198 // default - 0, landscape - 1
3199 switch (getResources().getConfiguration().orientation) {
3200 case Configuration.ORIENTATION_LANDSCAPE:
3201 return 1;
3202 default:
3203 return 0;
3204 }
3205 }
3206
Michael Jurkaae65ee32012-04-30 11:45:54 -07003207 private Drawable getExternalPackageToolbarIcon(ComponentName activityName, String resourceName) {
Michael Jurka0423dcf2010-10-05 14:56:18 -07003208 try {
Patrick Dubroyceae05d2010-08-30 10:40:53 -07003209 PackageManager packageManager = getPackageManager();
Michael Jurka0423dcf2010-10-05 14:56:18 -07003210 // Look for the toolbar icon specified in the activity meta-data
3211 Bundle metaData = packageManager.getActivityInfo(
3212 activityName, PackageManager.GET_META_DATA).metaData;
3213 if (metaData != null) {
Michael Jurkaae65ee32012-04-30 11:45:54 -07003214 int iconResId = metaData.getInt(resourceName);
Michael Jurka0423dcf2010-10-05 14:56:18 -07003215 if (iconResId != 0) {
3216 Resources res = packageManager.getResourcesForActivity(activityName);
Winson Chungfbb3d9b2011-03-01 12:43:02 -08003217 return res.getDrawable(iconResId);
Michael Jurka0423dcf2010-10-05 14:56:18 -07003218 }
3219 }
3220 } catch (NameNotFoundException e) {
Michael Jurkab6052a92011-07-12 17:02:45 -07003221 // This can happen if the activity defines an invalid drawable
3222 Log.w(TAG, "Failed to load toolbar icon; " + activityName.flattenToShortString() +
3223 " not found", e);
Mathew Inwood70d51022011-07-12 13:41:41 +01003224 } catch (Resources.NotFoundException nfe) {
3225 // This can happen if the activity defines an invalid drawable
3226 Log.w(TAG, "Failed to load toolbar icon from " + activityName.flattenToShortString(),
3227 nfe);
Michael Jurka0423dcf2010-10-05 14:56:18 -07003228 }
Winson Chungfbb3d9b2011-03-01 12:43:02 -08003229 return null;
3230 }
3231
3232 // if successful in getting icon, return it; otherwise, set button to use default drawable
3233 private Drawable.ConstantState updateTextButtonWithIconFromExternalActivity(
Michael Jurkaae65ee32012-04-30 11:45:54 -07003234 int buttonId, ComponentName activityName, int fallbackDrawableId,
3235 String toolbarResourceName) {
3236 Drawable toolbarIcon = getExternalPackageToolbarIcon(activityName, toolbarResourceName);
Winson Chung128bbcd2011-08-31 16:58:52 -07003237 Resources r = getResources();
3238 int w = r.getDimensionPixelSize(R.dimen.toolbar_external_icon_width);
3239 int h = r.getDimensionPixelSize(R.dimen.toolbar_external_icon_height);
Winson Chungfbb3d9b2011-03-01 12:43:02 -08003240
Michael Jurka4da7a3e2011-10-28 15:04:35 -07003241 TextView button = (TextView) findViewById(buttonId);
Winson Chungfbb3d9b2011-03-01 12:43:02 -08003242 // If we were unable to find the icon via the meta-data, use a generic one
3243 if (toolbarIcon == null) {
Winson Chung128bbcd2011-08-31 16:58:52 -07003244 toolbarIcon = r.getDrawable(fallbackDrawableId);
3245 toolbarIcon.setBounds(0, 0, w, h);
Michael Jurka4da7a3e2011-10-28 15:04:35 -07003246 if (button != null) {
3247 button.setCompoundDrawables(toolbarIcon, null, null, null);
3248 }
Winson Chungfbb3d9b2011-03-01 12:43:02 -08003249 return null;
3250 } else {
Winson Chung128bbcd2011-08-31 16:58:52 -07003251 toolbarIcon.setBounds(0, 0, w, h);
Michael Jurka4da7a3e2011-10-28 15:04:35 -07003252 if (button != null) {
3253 button.setCompoundDrawables(toolbarIcon, null, null, null);
3254 }
Winson Chungfbb3d9b2011-03-01 12:43:02 -08003255 return toolbarIcon.getConstantState();
3256 }
3257 }
3258
3259 // if successful in getting icon, return it; otherwise, set button to use default drawable
3260 private Drawable.ConstantState updateButtonWithIconFromExternalActivity(
Michael Jurkaae65ee32012-04-30 11:45:54 -07003261 int buttonId, ComponentName activityName, int fallbackDrawableId,
3262 String toolbarResourceName) {
Winson Chungfbb3d9b2011-03-01 12:43:02 -08003263 ImageView button = (ImageView) findViewById(buttonId);
Michael Jurkaae65ee32012-04-30 11:45:54 -07003264 Drawable toolbarIcon = getExternalPackageToolbarIcon(activityName, toolbarResourceName);
Winson Chungfbb3d9b2011-03-01 12:43:02 -08003265
Michael Jurka19e0fc52011-07-22 18:00:21 -07003266 if (button != null) {
3267 // If we were unable to find the icon via the meta-data, use a
3268 // generic one
3269 if (toolbarIcon == null) {
3270 button.setImageResource(fallbackDrawableId);
3271 } else {
3272 button.setImageDrawable(toolbarIcon);
3273 }
Michael Jurka0423dcf2010-10-05 14:56:18 -07003274 }
Michael Jurka19e0fc52011-07-22 18:00:21 -07003275
3276 return toolbarIcon != null ? toolbarIcon.getConstantState() : null;
3277
Michael Jurka0423dcf2010-10-05 14:56:18 -07003278 }
3279
Winson Chung1b884092012-06-08 17:13:02 -07003280 private void updateTextButtonWithDrawable(int buttonId, Drawable d) {
Winson Chungfbb3d9b2011-03-01 12:43:02 -08003281 TextView button = (TextView) findViewById(buttonId);
Winson Chung1b884092012-06-08 17:13:02 -07003282 button.setCompoundDrawables(d, null, null, null);
Winson Chungfbb3d9b2011-03-01 12:43:02 -08003283 }
3284
Michael Jurkae7bf83b2010-12-14 18:02:21 -08003285 private void updateButtonWithDrawable(int buttonId, Drawable.ConstantState d) {
Michael Jurka4ef207b2010-11-29 17:05:45 -08003286 ImageView button = (ImageView) findViewById(buttonId);
Michael Jurkae7bf83b2010-12-14 18:02:21 -08003287 button.setImageDrawable(d.newDrawable(getResources()));
Michael Jurka4ef207b2010-11-29 17:05:45 -08003288 }
3289
Winson Chungbb185bd2011-11-21 12:31:42 -08003290 private void invalidatePressedFocusedStates(View container, View button) {
3291 if (container instanceof HolographicLinearLayout) {
3292 HolographicLinearLayout layout = (HolographicLinearLayout) container;
3293 layout.invalidatePressedFocusedStates();
3294 } else if (button instanceof HolographicImageView) {
3295 HolographicImageView view = (HolographicImageView) button;
3296 view.invalidatePressedFocusedStates();
3297 }
3298 }
3299
Cristina Stancu476493b2013-08-07 17:20:14 +01003300 public View getQsbBar() {
3301 if (mQsbBar == null) {
Winson Chung54e65132013-09-27 11:44:58 -07003302 mQsbBar = mInflater.inflate(R.layout.search_bar, mSearchDropTargetBar, false);
3303 mSearchDropTargetBar.addView(mQsbBar);
Cristina Stancu476493b2013-08-07 17:20:14 +01003304 }
3305 return mQsbBar;
3306 }
3307
3308 protected boolean updateGlobalSearchIcon() {
Winson Chungc51db6a2011-10-05 11:44:49 -07003309 final View searchButtonContainer = findViewById(R.id.search_button_container);
Winson Chung1cad91e2011-05-25 17:41:01 -07003310 final ImageView searchButton = (ImageView) findViewById(R.id.search_button);
Winson Chungc51db6a2011-10-05 11:44:49 -07003311 final View voiceButtonContainer = findViewById(R.id.voice_button_container);
Winson Chungcbf7c4d2011-08-23 11:58:54 -07003312 final View voiceButton = findViewById(R.id.voice_button);
Winson Chung97d85d22011-04-13 11:27:36 -07003313
Winson Chung1cad91e2011-05-25 17:41:01 -07003314 final SearchManager searchManager =
3315 (SearchManager) getSystemService(Context.SEARCH_SERVICE);
3316 ComponentName activityName = searchManager.getGlobalSearchActivity();
3317 if (activityName != null) {
Winson Chungdff8ebb2011-09-08 17:25:31 -07003318 int coi = getCurrentOrientationIndexForGlobalIcons();
3319 sGlobalSearchIcon[coi] = updateButtonWithIconFromExternalActivity(
Michael Jurkaae65ee32012-04-30 11:45:54 -07003320 R.id.search_button, activityName, R.drawable.ic_home_search_normal_holo,
3321 TOOLBAR_SEARCH_ICON_METADATA_NAME);
3322 if (sGlobalSearchIcon[coi] == null) {
3323 sGlobalSearchIcon[coi] = updateButtonWithIconFromExternalActivity(
3324 R.id.search_button, activityName, R.drawable.ic_home_search_normal_holo,
3325 TOOLBAR_ICON_METADATA_NAME);
3326 }
3327
Winson Chungc51db6a2011-10-05 11:44:49 -07003328 if (searchButtonContainer != null) searchButtonContainer.setVisibility(View.VISIBLE);
3329 searchButton.setVisibility(View.VISIBLE);
Winson Chungbb185bd2011-11-21 12:31:42 -08003330 invalidatePressedFocusedStates(searchButtonContainer, searchButton);
Winson Chungc51db6a2011-10-05 11:44:49 -07003331 return true;
Winson Chung1cad91e2011-05-25 17:41:01 -07003332 } else {
Winson Chungcbf7c4d2011-08-23 11:58:54 -07003333 // We disable both search and voice search when there is no global search provider
Winson Chungc51db6a2011-10-05 11:44:49 -07003334 if (searchButtonContainer != null) searchButtonContainer.setVisibility(View.GONE);
3335 if (voiceButtonContainer != null) voiceButtonContainer.setVisibility(View.GONE);
John Spurlock2c38e702013-09-18 10:48:25 -04003336 if (searchButton != null) searchButton.setVisibility(View.GONE);
3337 if (voiceButton != null) voiceButton.setVisibility(View.GONE);
Winson Chung5841efa2013-09-30 18:06:44 -07003338 updateVoiceButtonProxyVisible(false);
Winson Chungc51db6a2011-10-05 11:44:49 -07003339 return false;
Amith Yamasani6d7fe502010-11-16 09:05:07 -08003340 }
3341 }
3342
Cristina Stancu476493b2013-08-07 17:20:14 +01003343 protected void updateGlobalSearchIcon(Drawable.ConstantState d) {
Winson Chungbb185bd2011-11-21 12:31:42 -08003344 final View searchButtonContainer = findViewById(R.id.search_button_container);
3345 final View searchButton = (ImageView) findViewById(R.id.search_button);
Michael Jurka4ef207b2010-11-29 17:05:45 -08003346 updateButtonWithDrawable(R.id.search_button, d);
Winson Chungbb185bd2011-11-21 12:31:42 -08003347 invalidatePressedFocusedStates(searchButtonContainer, searchButton);
Michael Jurka4ef207b2010-11-29 17:05:45 -08003348 }
3349
Cristina Stancu476493b2013-08-07 17:20:14 +01003350 protected boolean updateVoiceSearchIcon(boolean searchVisible) {
Winson Chungc51db6a2011-10-05 11:44:49 -07003351 final View voiceButtonContainer = findViewById(R.id.voice_button_container);
Winson Chung1cad91e2011-05-25 17:41:01 -07003352 final View voiceButton = findViewById(R.id.voice_button);
Winson Chung97d85d22011-04-13 11:27:36 -07003353
Winson Chungc51db6a2011-10-05 11:44:49 -07003354 // We only show/update the voice search icon if the search icon is enabled as well
Michael Jurkaae65ee32012-04-30 11:45:54 -07003355 final SearchManager searchManager =
3356 (SearchManager) getSystemService(Context.SEARCH_SERVICE);
3357 ComponentName globalSearchActivity = searchManager.getGlobalSearchActivity();
3358
3359 ComponentName activityName = null;
3360 if (globalSearchActivity != null) {
3361 // Check if the global search activity handles voice search
3362 Intent intent = new Intent(RecognizerIntent.ACTION_WEB_SEARCH);
3363 intent.setPackage(globalSearchActivity.getPackageName());
3364 activityName = intent.resolveActivity(getPackageManager());
3365 }
3366
3367 if (activityName == null) {
3368 // Fallback: check if an activity other than the global search activity
3369 // resolves this
3370 Intent intent = new Intent(RecognizerIntent.ACTION_WEB_SEARCH);
3371 activityName = intent.resolveActivity(getPackageManager());
3372 }
Winson Chungc51db6a2011-10-05 11:44:49 -07003373 if (searchVisible && activityName != null) {
Winson Chungdff8ebb2011-09-08 17:25:31 -07003374 int coi = getCurrentOrientationIndexForGlobalIcons();
3375 sVoiceSearchIcon[coi] = updateButtonWithIconFromExternalActivity(
Michael Jurkaae65ee32012-04-30 11:45:54 -07003376 R.id.voice_button, activityName, R.drawable.ic_home_voice_search_holo,
3377 TOOLBAR_VOICE_SEARCH_ICON_METADATA_NAME);
3378 if (sVoiceSearchIcon[coi] == null) {
3379 sVoiceSearchIcon[coi] = updateButtonWithIconFromExternalActivity(
3380 R.id.voice_button, activityName, R.drawable.ic_home_voice_search_holo,
3381 TOOLBAR_ICON_METADATA_NAME);
3382 }
Winson Chungc51db6a2011-10-05 11:44:49 -07003383 if (voiceButtonContainer != null) voiceButtonContainer.setVisibility(View.VISIBLE);
Winson Chung1cad91e2011-05-25 17:41:01 -07003384 voiceButton.setVisibility(View.VISIBLE);
Winson Chung5841efa2013-09-30 18:06:44 -07003385 updateVoiceButtonProxyVisible(false);
Winson Chungbb185bd2011-11-21 12:31:42 -08003386 invalidatePressedFocusedStates(voiceButtonContainer, voiceButton);
Winson Chungc51db6a2011-10-05 11:44:49 -07003387 return true;
Winson Chung1cad91e2011-05-25 17:41:01 -07003388 } else {
Winson Chungc51db6a2011-10-05 11:44:49 -07003389 if (voiceButtonContainer != null) voiceButtonContainer.setVisibility(View.GONE);
John Spurlock2c38e702013-09-18 10:48:25 -04003390 if (voiceButton != null) voiceButton.setVisibility(View.GONE);
Winson Chung5841efa2013-09-30 18:06:44 -07003391 updateVoiceButtonProxyVisible(false);
Winson Chungc51db6a2011-10-05 11:44:49 -07003392 return false;
Patrick Dubroyceae05d2010-08-30 10:40:53 -07003393 }
Michael Jurka6ae0fcf2010-10-01 12:23:12 -07003394 }
Michael Jurka0423dcf2010-10-05 14:56:18 -07003395
Cristina Stancu476493b2013-08-07 17:20:14 +01003396 protected void updateVoiceSearchIcon(Drawable.ConstantState d) {
Winson Chungbb185bd2011-11-21 12:31:42 -08003397 final View voiceButtonContainer = findViewById(R.id.voice_button_container);
3398 final View voiceButton = findViewById(R.id.voice_button);
Michael Jurka4ef207b2010-11-29 17:05:45 -08003399 updateButtonWithDrawable(R.id.voice_button, d);
Winson Chungbb185bd2011-11-21 12:31:42 -08003400 invalidatePressedFocusedStates(voiceButtonContainer, voiceButton);
Michael Jurka4ef207b2010-11-29 17:05:45 -08003401 }
3402
Winson Chung5841efa2013-09-30 18:06:44 -07003403 public void updateVoiceButtonProxyVisible(boolean forceDisableVoiceButtonProxy) {
Bjorn Bringertecf33e42013-06-11 15:46:07 +01003404 final View voiceButtonProxy = findViewById(R.id.voice_button_proxy);
3405 if (voiceButtonProxy != null) {
Winson Chung5841efa2013-09-30 18:06:44 -07003406 boolean visible = !forceDisableVoiceButtonProxy &&
3407 mWorkspace.shouldVoiceButtonProxyBeVisible();
Bjorn Bringertecf33e42013-06-11 15:46:07 +01003408 voiceButtonProxy.setVisibility(visible ? View.VISIBLE : View.GONE);
Winson Chung5841efa2013-09-30 18:06:44 -07003409 voiceButtonProxy.bringToFront();
Bjorn Bringertecf33e42013-06-11 15:46:07 +01003410 }
3411 }
Winson Chung5841efa2013-09-30 18:06:44 -07003412
3413 /**
3414 * This is an overrid eot disable the voice button proxy. If disabled is true, then the voice button proxy
3415 * will be hidden regardless of what shouldVoiceButtonProxyBeVisible() returns.
3416 */
3417 public void disableVoiceButtonProxy(boolean disabled) {
3418 updateVoiceButtonProxyVisible(disabled);
3419 }
Michael Jurka6ae0fcf2010-10-01 12:23:12 -07003420 /**
Winson Chungeb66b142011-06-16 13:14:22 -07003421 * Sets the app market icon
Michael Jurka6ae0fcf2010-10-01 12:23:12 -07003422 */
3423 private void updateAppMarketIcon() {
Winson Chungd64a6662013-09-30 11:06:59 -07003424 if (!DISABLE_MARKET_BUTTON) {
3425 final View marketButton = findViewById(R.id.market_button);
3426 Intent intent = new Intent(Intent.ACTION_MAIN).addCategory(Intent.CATEGORY_APP_MARKET);
3427 // Find the app market activity by resolving an intent.
3428 // (If multiple app markets are installed, it will return the ResolverActivity.)
3429 ComponentName activityName = intent.resolveActivity(getPackageManager());
3430 if (activityName != null) {
3431 int coi = getCurrentOrientationIndexForGlobalIcons();
3432 mAppMarketIntent = intent;
3433 sAppMarketIcon[coi] = updateTextButtonWithIconFromExternalActivity(
3434 R.id.market_button, activityName, R.drawable.ic_launcher_market_holo,
3435 TOOLBAR_ICON_METADATA_NAME);
3436 marketButton.setVisibility(View.VISIBLE);
3437 } else {
3438 // We should hide and disable the view so that we don't try and restore the visibility
3439 // of it when we swap between drag & normal states from IconDropTarget subclasses.
3440 marketButton.setVisibility(View.GONE);
3441 marketButton.setEnabled(false);
3442 }
Michael Jurka0423dcf2010-10-05 14:56:18 -07003443 }
Patrick Dubroyceae05d2010-08-30 10:40:53 -07003444 }
3445
Michael Jurkae7bf83b2010-12-14 18:02:21 -08003446 private void updateAppMarketIcon(Drawable.ConstantState d) {
Winson Chungd64a6662013-09-30 11:06:59 -07003447 if (!DISABLE_MARKET_BUTTON) {
3448 // Ensure that the new drawable we are creating has the approprate toolbar icon bounds
3449 Resources r = getResources();
3450 Drawable marketIconDrawable = d.newDrawable(r);
3451 int w = r.getDimensionPixelSize(R.dimen.toolbar_external_icon_width);
3452 int h = r.getDimensionPixelSize(R.dimen.toolbar_external_icon_height);
3453 marketIconDrawable.setBounds(0, 0, w, h);
Winson Chung1b884092012-06-08 17:13:02 -07003454
Winson Chungd64a6662013-09-30 11:06:59 -07003455 updateTextButtonWithDrawable(R.id.market_button, marketIconDrawable);
3456 }
Michael Jurka4ef207b2010-11-29 17:05:45 -08003457 }
3458
Michael Jurkad7c28052012-04-27 15:43:36 -07003459 @Override
3460 public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
alanv1d4fde62012-10-17 13:15:47 -07003461 final boolean result = super.dispatchPopulateAccessibilityEvent(event);
Michael Jurkad7c28052012-04-27 15:43:36 -07003462 final List<CharSequence> text = event.getText();
3463 text.clear();
alanv1d4fde62012-10-17 13:15:47 -07003464 // Populate event with a fake title based on the current state.
3465 if (mState == State.APPS_CUSTOMIZE) {
3466 text.add(getString(R.string.all_apps_button_label));
3467 } else {
3468 text.add(getString(R.string.all_apps_home_button_label));
3469 }
Michael Jurkad7c28052012-04-27 15:43:36 -07003470 return result;
3471 }
3472
Patrick Dubroyceae05d2010-08-30 10:40:53 -07003473 /**
Winson Chungb8472bb2011-08-05 13:49:21 -07003474 * Receives notifications when system dialogs are to be closed.
Joe Onorato2ca0ae72009-11-10 13:14:13 -08003475 */
3476 private class CloseSystemDialogsIntentReceiver extends BroadcastReceiver {
3477 @Override
3478 public void onReceive(Context context, Intent intent) {
Joe Onorato2ca0ae72009-11-10 13:14:13 -08003479 closeSystemDialogs();
3480 }
3481 }
3482
3483 /**
Jeff Sharkey1e2efc82009-11-06 15:17:59 -08003484 * Receives notifications whenever the appwidgets are reset.
3485 */
3486 private class AppWidgetResetObserver extends ContentObserver {
3487 public AppWidgetResetObserver() {
3488 super(new Handler());
3489 }
3490
3491 @Override
3492 public void onChange(boolean selfChange) {
3493 onAppWidgetReset();
3494 }
3495 }
3496
3497 /**
Michael Jurka7607c2f2013-04-03 14:33:19 -07003498 * If the activity is currently paused, signal that we need to run the passed Runnable
3499 * in onResume.
3500 *
3501 * This needs to be called from incoming places where resources might have been loaded
3502 * while we are paused. That is becaues the Configuration might be wrong
3503 * when we're not running, and if it comes back to what it was when we
3504 * were paused, we are not restarted.
3505 *
3506 * Implementation of the method from LauncherModel.Callbacks.
3507 *
3508 * @return true if we are currently paused. The caller might be able to
3509 * skip some work in that case since we will come back again.
3510 */
Michael Jurkac402cd92013-05-20 15:49:32 +02003511 private boolean waitUntilResume(Runnable run, boolean deletePreviousRunnables) {
Michael Jurka7607c2f2013-04-03 14:33:19 -07003512 if (mPaused) {
3513 Log.i(TAG, "Deferring update until onResume");
Michael Jurkac402cd92013-05-20 15:49:32 +02003514 if (deletePreviousRunnables) {
Michael Jurka1e2f4652013-07-08 18:03:46 -07003515 while (mBindOnResumeCallbacks.remove(run)) {
Michael Jurkac402cd92013-05-20 15:49:32 +02003516 }
3517 }
Michael Jurka1e2f4652013-07-08 18:03:46 -07003518 mBindOnResumeCallbacks.add(run);
Michael Jurka7607c2f2013-04-03 14:33:19 -07003519 return true;
3520 } else {
3521 return false;
3522 }
3523 }
3524
Michael Jurkac402cd92013-05-20 15:49:32 +02003525 private boolean waitUntilResume(Runnable run) {
3526 return waitUntilResume(run, false);
3527 }
3528
Michael Jurka1e2f4652013-07-08 18:03:46 -07003529 public void addOnResumeCallback(Runnable run) {
Michael Jurka54554252013-08-01 12:52:23 +02003530 mOnResumeCallbacks.add(run);
Michael Jurka1e2f4652013-07-08 18:03:46 -07003531 }
3532
Michael Jurka7607c2f2013-04-03 14:33:19 -07003533 /**
Joe Onoratoef2efcf2010-10-27 13:21:00 -07003534 * If the activity is currently paused, signal that we need to re-run the loader
3535 * in onResume.
3536 *
3537 * This needs to be called from incoming places where resources might have been loaded
3538 * while we are paused. That is becaues the Configuration might be wrong
3539 * when we're not running, and if it comes back to what it was when we
3540 * were paused, we are not restarted.
3541 *
3542 * Implementation of the method from LauncherModel.Callbacks.
3543 *
3544 * @return true if we are currently paused. The caller might be able to
3545 * skip some work in that case since we will come back again.
3546 */
3547 public boolean setLoadOnResume() {
3548 if (mPaused) {
3549 Log.i(TAG, "setLoadOnResume");
3550 mOnResumeNeedsLoad = true;
3551 return true;
3552 } else {
3553 return false;
3554 }
3555 }
3556
3557 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04003558 * Implementation of the method from LauncherModel.Callbacks.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003559 */
Joe Onorato9c1289c2009-08-17 11:03:03 -04003560 public int getCurrentWorkspaceScreen() {
Joe Onoratod0afc872010-06-11 00:03:15 -07003561 if (mWorkspace != null) {
Michael Jurka0142d492010-08-25 17:46:15 -07003562 return mWorkspace.getCurrentPage();
Joe Onoratod0afc872010-06-11 00:03:15 -07003563 } else {
3564 return SCREEN_COUNT / 2;
3565 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04003566 }
The Android Open Source Projectf96811c2009-03-18 17:39:48 -07003567
Joe Onorato9c1289c2009-08-17 11:03:03 -04003568 /**
3569 * Refreshes the shortcuts shown on the workspace.
3570 *
3571 * Implementation of the method from LauncherModel.Callbacks.
3572 */
3573 public void startBinding() {
Michael Jurka7607c2f2013-04-03 14:33:19 -07003574 // If we're starting binding all over again, clear any bind calls we'd postponed in
3575 // the past (see waitUntilResume) -- we don't need them since we're starting binding
3576 // from scratch again
Michael Jurka1e2f4652013-07-08 18:03:46 -07003577 mBindOnResumeCallbacks.clear();
Adam Cohendf035382011-04-11 17:22:04 -07003578
Winson Chungd64d1762013-08-20 14:37:16 -07003579 // Clear the workspace because it's going to be rebound
Adam Cohendf035382011-04-11 17:22:04 -07003580 mWorkspace.clearDropTargets();
Winson Chung9e6a0a22013-08-27 11:58:12 -07003581 mWorkspace.removeAllWorkspaceScreens();
Winson Chungd64d1762013-08-20 14:37:16 -07003582
Michael Jurka05bf6442011-11-30 20:28:53 -08003583 mWidgetsToAdvance.clear();
Winson Chung3d503fb2011-07-13 17:25:49 -07003584 if (mHotseat != null) {
3585 mHotseat.resetLayout();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003586 }
3587 }
3588
Adam Cohendcd297f2013-06-18 13:13:40 -07003589 @Override
3590 public void bindScreens(ArrayList<Long> orderedScreenIds) {
Winson Chung64359a52013-07-08 17:17:08 -07003591 bindAddScreens(orderedScreenIds);
Winson Chung0e6a7132013-08-23 12:55:10 -07003592
Adam Cohen5084cba2013-09-03 12:01:16 -07003593 // If there are no screens, we need to have an empty screen
3594 if (orderedScreenIds.size() == 0) {
3595 mWorkspace.addExtraEmptyScreen();
3596 }
Winson Chung0e6a7132013-08-23 12:55:10 -07003597
3598 // Create the custom content page (this call updates mDefaultScreen which calls
Dave Hawkeya8881582013-09-17 15:55:33 -06003599 // setCurrentPage() so ensure that all pages are added before calling this).
3600 // The actual content of the custom page will be added during onFinishBindingItems().
Winson Chung0e6a7132013-08-23 12:55:10 -07003601 if (!mWorkspace.hasCustomContent() && hasCustomContentToLeft()) {
3602 mWorkspace.createCustomContentPage();
3603 }
Winson Chung64359a52013-07-08 17:17:08 -07003604 }
3605
3606 @Override
3607 public void bindAddScreens(ArrayList<Long> orderedScreenIds) {
Adam Cohendcd297f2013-06-18 13:13:40 -07003608 int count = orderedScreenIds.size();
3609 for (int i = 0; i < count; i++) {
Adam Cohen89bddfa2013-08-20 11:57:13 -07003610 mWorkspace.insertNewWorkspaceScreenBeforeEmptyScreen(orderedScreenIds.get(i));
Adam Cohendcd297f2013-06-18 13:13:40 -07003611 }
Adam Cohendcd297f2013-06-18 13:13:40 -07003612 }
3613
Adam Cohen39a06042013-07-19 14:30:12 -07003614 private boolean shouldShowWeightWatcher() {
3615 String spKey = LauncherAppState.getSharedPreferencesKey();
3616 SharedPreferences sp = getSharedPreferences(spKey, Context.MODE_PRIVATE);
Daniel Sandler6053b802013-08-15 15:44:26 -07003617 boolean show = sp.getBoolean(SHOW_WEIGHT_WATCHER, SHOW_WEIGHT_WATCHER_DEFAULT);
Adam Cohen39a06042013-07-19 14:30:12 -07003618
3619 return show;
3620 }
3621
3622 private void toggleShowWeightWatcher() {
3623 String spKey = LauncherAppState.getSharedPreferencesKey();
3624 SharedPreferences sp = getSharedPreferences(spKey, Context.MODE_PRIVATE);
3625 boolean show = sp.getBoolean(SHOW_WEIGHT_WATCHER, true);
3626
3627 show = !show;
3628
3629 SharedPreferences.Editor editor = sp.edit();
3630 editor.putBoolean(SHOW_WEIGHT_WATCHER, show);
3631 editor.commit();
3632
3633 if (mWeightWatcher != null) {
3634 mWeightWatcher.setVisibility(show ? View.VISIBLE : View.GONE);
3635 }
3636 }
3637
Winson Chungd64d1762013-08-20 14:37:16 -07003638 public void bindAppsAdded(final ArrayList<Long> newScreens,
3639 final ArrayList<ItemInfo> addNotAnimated,
Winson Chungc58497e2013-09-03 17:48:37 -07003640 final ArrayList<ItemInfo> addAnimated,
3641 final ArrayList<AppInfo> addedApps) {
Winson Chungd64d1762013-08-20 14:37:16 -07003642 Runnable r = new Runnable() {
3643 public void run() {
Winson Chungc58497e2013-09-03 17:48:37 -07003644 bindAppsAdded(newScreens, addNotAnimated, addAnimated, addedApps);
Winson Chungd64d1762013-08-20 14:37:16 -07003645 }
3646 };
3647 if (waitUntilResume(r)) {
3648 return;
3649 }
3650
Winson Chungd64d1762013-08-20 14:37:16 -07003651 // Add the new screens
3652 bindAddScreens(newScreens);
3653
3654 // We add the items without animation on non-visible pages, and with
3655 // animations on the new page (which we will try and snap to).
3656 if (!addNotAnimated.isEmpty()) {
3657 bindItems(addNotAnimated, 0,
3658 addNotAnimated.size(), false);
3659 }
3660 if (!addAnimated.isEmpty()) {
3661 bindItems(addAnimated, 0,
3662 addAnimated.size(), true);
3663 }
Winson Chungc58497e2013-09-03 17:48:37 -07003664
3665 if (!AppsCustomizePagedView.DISABLE_ALL_APPS &&
3666 addedApps != null && mAppsCustomizeContent != null) {
3667 mAppsCustomizeContent.addApps(addedApps);
3668 }
Winson Chungd64d1762013-08-20 14:37:16 -07003669 }
3670
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003671 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04003672 * Bind the items start-end from the list.
3673 *
3674 * Implementation of the method from LauncherModel.Callbacks.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003675 */
Winson Chung64359a52013-07-08 17:17:08 -07003676 public void bindItems(final ArrayList<ItemInfo> shortcuts, final int start, final int end,
3677 final boolean forceAnimateIcons) {
Winson Chungd64d1762013-08-20 14:37:16 -07003678 Runnable r = new Runnable() {
3679 public void run() {
3680 bindItems(shortcuts, start, end, forceAnimateIcons);
3681 }
3682 };
3683 if (waitUntilResume(r)) {
Michael Jurka7607c2f2013-04-03 14:33:19 -07003684 return;
3685 }
Joe Onoratoef2efcf2010-10-27 13:21:00 -07003686
Winson Chungf0c6ae02012-03-21 16:10:31 -07003687 // Get the list of added shortcuts and intersect them with the set of shortcuts here
Winson Chung64359a52013-07-08 17:17:08 -07003688 final AnimatorSet anim = LauncherAnimUtils.createAnimatorSet();
3689 final Collection<Animator> bounceAnims = new ArrayList<Animator>();
Winson Chung997a9232013-07-24 15:33:46 -07003690 final boolean animateIcons = forceAnimateIcons && canRunNewAppsAnimation();
Winson Chungf0c6ae02012-03-21 16:10:31 -07003691 Workspace workspace = mWorkspace;
Winson Chung997a9232013-07-24 15:33:46 -07003692 long newShortcutsScreenId = -1;
Winson Chungf0c6ae02012-03-21 16:10:31 -07003693 for (int i = start; i < end; i++) {
Joe Onorato9c1289c2009-08-17 11:03:03 -04003694 final ItemInfo item = shortcuts.get(i);
Winson Chung4d279d92011-07-21 11:46:32 -07003695
3696 // Short circuit if we are loading dock items for a configuration which has no dock
3697 if (item.container == LauncherSettings.Favorites.CONTAINER_HOTSEAT &&
3698 mHotseat == null) {
3699 continue;
3700 }
3701
Joe Onorato9c1289c2009-08-17 11:03:03 -04003702 switch (item.itemType) {
3703 case LauncherSettings.Favorites.ITEM_TYPE_APPLICATION:
3704 case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT:
Winson Chungf0c6ae02012-03-21 16:10:31 -07003705 ShortcutInfo info = (ShortcutInfo) item;
Winson Chungf0c6ae02012-03-21 16:10:31 -07003706 View shortcut = createShortcut(info);
Adam Cohendcd297f2013-06-18 13:13:40 -07003707
Winson Chung64359a52013-07-08 17:17:08 -07003708 /*
3709 * TODO: FIX collision case
3710 */
Winson Chungce376632013-07-11 16:12:41 -07003711 if (item.container == LauncherSettings.Favorites.CONTAINER_DESKTOP) {
3712 CellLayout cl = mWorkspace.getScreenWithId(item.screenId);
3713 if (cl != null && cl.isOccupied(item.cellX, item.cellY)) {
3714 throw new RuntimeException("OCCUPIED");
3715 }
Winson Chung64359a52013-07-08 17:17:08 -07003716 }
3717
Adam Cohendcd297f2013-06-18 13:13:40 -07003718 workspace.addInScreenFromBind(shortcut, item.container, item.screenId, item.cellX,
3719 item.cellY, 1, 1);
Winson Chung997a9232013-07-24 15:33:46 -07003720 if (animateIcons) {
Winson Chung64359a52013-07-08 17:17:08 -07003721 // Animate all the applications up now
3722 shortcut.setAlpha(0f);
3723 shortcut.setScaleX(0f);
3724 shortcut.setScaleY(0f);
3725 bounceAnims.add(createNewAppBounceAnimation(shortcut, i));
Winson Chung997a9232013-07-24 15:33:46 -07003726 newShortcutsScreenId = item.screenId;
Winson Chungf0c6ae02012-03-21 16:10:31 -07003727 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04003728 break;
Adam Cohendf2cc412011-04-27 16:56:57 -07003729 case LauncherSettings.Favorites.ITEM_TYPE_FOLDER:
Winson Chung3d503fb2011-07-13 17:25:49 -07003730 FolderIcon newFolder = FolderIcon.fromXml(R.layout.folder_icon, this,
Michael Jurka0142d492010-08-25 17:46:15 -07003731 (ViewGroup) workspace.getChildAt(workspace.getCurrentPage()),
Adam Cohendf2cc412011-04-27 16:56:57 -07003732 (FolderInfo) item, mIconCache);
Adam Cohendcd297f2013-06-18 13:13:40 -07003733 workspace.addInScreenFromBind(newFolder, item.container, item.screenId, item.cellX,
3734 item.cellY, 1, 1);
Joe Onorato9c1289c2009-08-17 11:03:03 -04003735 break;
Winson Chungc763c4e2013-07-19 13:49:06 -07003736 default:
3737 throw new RuntimeException("Invalid Item Type");
Joe Onorato9c1289c2009-08-17 11:03:03 -04003738 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003739 }
Winson Chungf0c6ae02012-03-21 16:10:31 -07003740
Winson Chung997a9232013-07-24 15:33:46 -07003741 if (animateIcons) {
3742 // Animate to the correct page
3743 if (newShortcutsScreenId > -1) {
3744 long currentScreenId = mWorkspace.getScreenIdForPageIndex(mWorkspace.getNextPage());
Winson Chung94d67682013-09-25 16:29:40 -07003745 final int newScreenIndex = mWorkspace.getPageIndexForScreenId(newShortcutsScreenId);
Winson Chung997a9232013-07-24 15:33:46 -07003746 if (newShortcutsScreenId != currentScreenId) {
Winson Chung94d67682013-09-25 16:29:40 -07003747 // We post the animation slightly delayed to prevent slowdowns
3748 // when we are loading right after we return to launcher.
3749 mWorkspace.postDelayed(new Runnable() {
3750 public void run() {
3751 mWorkspace.snapToPage(newScreenIndex);
3752 mWorkspace.postDelayed(new Runnable() {
3753 public void run() {
3754 anim.playTogether(bounceAnims);
3755 anim.start();
3756 }
3757 }, NEW_APPS_ANIMATION_DELAY);
3758 }
3759 }, NEW_APPS_PAGE_MOVE_DELAY);
Winson Chung997a9232013-07-24 15:33:46 -07003760 }
3761 }
Winson Chung64359a52013-07-08 17:17:08 -07003762 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04003763 workspace.requestLayout();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003764 }
3765
Joe Onorato9c1289c2009-08-17 11:03:03 -04003766 /**
3767 * Implementation of the method from LauncherModel.Callbacks.
3768 */
Michael Jurka7607c2f2013-04-03 14:33:19 -07003769 public void bindFolders(final HashMap<Long, FolderInfo> folders) {
Winson Chungd64d1762013-08-20 14:37:16 -07003770 Runnable r = new Runnable() {
3771 public void run() {
3772 bindFolders(folders);
3773 }
3774 };
3775 if (waitUntilResume(r)) {
Michael Jurka7607c2f2013-04-03 14:33:19 -07003776 return;
3777 }
Brad Fitzpatrick319226a2010-09-01 13:45:16 -07003778 sFolders.clear();
3779 sFolders.putAll(folders);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003780 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04003781
3782 /**
3783 * Add the views for a widget to the workspace.
3784 *
3785 * Implementation of the method from LauncherModel.Callbacks.
3786 */
Michael Jurka7607c2f2013-04-03 14:33:19 -07003787 public void bindAppWidget(final LauncherAppWidgetInfo item) {
Winson Chungd64d1762013-08-20 14:37:16 -07003788 Runnable r = new Runnable() {
3789 public void run() {
3790 bindAppWidget(item);
3791 }
3792 };
3793 if (waitUntilResume(r)) {
Michael Jurka7607c2f2013-04-03 14:33:19 -07003794 return;
3795 }
Joe Onoratoef2efcf2010-10-27 13:21:00 -07003796
Daniel Sandler843e8602010-06-07 14:59:01 -04003797 final long start = DEBUG_WIDGETS ? SystemClock.uptimeMillis() : 0;
3798 if (DEBUG_WIDGETS) {
3799 Log.d(TAG, "bindAppWidget: " + item);
3800 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04003801 final Workspace workspace = mWorkspace;
3802
3803 final int appWidgetId = item.appWidgetId;
3804 final AppWidgetProviderInfo appWidgetInfo = mAppWidgetManager.getAppWidgetInfo(appWidgetId);
Daniel Sandler843e8602010-06-07 14:59:01 -04003805 if (DEBUG_WIDGETS) {
3806 Log.d(TAG, "bindAppWidget: id=" + item.appWidgetId + " belongs to component " + appWidgetInfo.provider);
3807 }
3808
Joe Onorato9c1289c2009-08-17 11:03:03 -04003809 item.hostView = mAppWidgetHost.createView(this, appWidgetId, appWidgetInfo);
3810
Joe Onorato9c1289c2009-08-17 11:03:03 -04003811 item.hostView.setTag(item);
Winson Chung211bac32012-05-15 13:43:57 -07003812 item.onBindAppWidget(this);
Joe Onorato9c1289c2009-08-17 11:03:03 -04003813
Adam Cohendcd297f2013-06-18 13:13:40 -07003814 workspace.addInScreen(item.hostView, item.container, item.screenId, item.cellX,
Joe Onorato9c1289c2009-08-17 11:03:03 -04003815 item.cellY, item.spanX, item.spanY, false);
Adam Cohended9f8d2010-11-03 13:25:16 -07003816 addWidgetToAutoAdvanceIfNeeded(item.hostView, appWidgetInfo);
3817
Joe Onorato9c1289c2009-08-17 11:03:03 -04003818 workspace.requestLayout();
3819
Daniel Sandler843e8602010-06-07 14:59:01 -04003820 if (DEBUG_WIDGETS) {
3821 Log.d(TAG, "bound widget id="+item.appWidgetId+" in "
3822 + (SystemClock.uptimeMillis()-start) + "ms");
3823 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04003824 }
3825
Adam Cohen1462de32012-07-24 22:34:36 -07003826 public void onPageBoundSynchronously(int page) {
3827 mSynchronouslyBoundPages.add(page);
3828 }
3829
Joe Onorato9c1289c2009-08-17 11:03:03 -04003830 /**
3831 * Callback saying that there aren't any more items to bind.
3832 *
3833 * Implementation of the method from LauncherModel.Callbacks.
3834 */
Adam Cohene25af792013-06-06 23:08:25 -07003835 public void finishBindingItems(final boolean upgradePath) {
Winson Chungd64d1762013-08-20 14:37:16 -07003836 Runnable r = new Runnable() {
3837 public void run() {
3838 finishBindingItems(upgradePath);
3839 }
3840 };
3841 if (waitUntilResume(r)) {
Michael Jurka7607c2f2013-04-03 14:33:19 -07003842 return;
3843 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04003844 if (mSavedState != null) {
3845 if (!mWorkspace.hasFocus()) {
Michael Jurka0142d492010-08-25 17:46:15 -07003846 mWorkspace.getChildAt(mWorkspace.getCurrentPage()).requestFocus();
Joe Onorato9c1289c2009-08-17 11:03:03 -04003847 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04003848 mSavedState = null;
3849 }
3850
Adam Cohen1462de32012-07-24 22:34:36 -07003851 mWorkspace.restoreInstanceStateForRemainingPages();
Joe Onorato9c1289c2009-08-17 11:03:03 -04003852
Patrick Dubroy002cbf42011-03-03 16:36:21 -08003853 // If we received the result of any pending adds while the loader was running (e.g. the
3854 // widget configuration forced an orientation change), process them now.
3855 for (int i = 0; i < sPendingAddList.size(); i++) {
3856 completeAdd(sPendingAddList.get(i));
3857 }
3858 sPendingAddList.clear();
Joe Onorato9c1289c2009-08-17 11:03:03 -04003859
Winson Chungc51db6a2011-10-05 11:44:49 -07003860 // Update the market app icon as necessary (the other icons will be managed in response to
3861 // package changes in bindSearchablesChanged()
Winson Chungd64a6662013-09-30 11:06:59 -07003862 if (!DISABLE_MARKET_BUTTON) {
3863 updateAppMarketIcon();
3864 }
Michael Jurkac1f5d262011-09-30 19:32:27 -07003865
Winson Chungf0c6ae02012-03-21 16:10:31 -07003866 mWorkspaceLoading = false;
Adam Cohene25af792013-06-06 23:08:25 -07003867 if (upgradePath) {
Adam Cohen4caf2982013-08-20 18:54:31 -07003868 mWorkspace.getUniqueComponents(true, null);
3869 mIntentsOnWorkspaceFromUpgradePath = mWorkspace.getUniqueComponents(true, null);
Adam Cohene25af792013-06-06 23:08:25 -07003870 }
Adam Cohen99894d92013-06-14 11:22:59 -07003871
Adam Cohen66a01fd2013-06-11 12:48:00 -07003872 mWorkspace.post(new Runnable() {
3873 @Override
3874 public void run() {
3875 onFinishBindingItems();
3876 }
3877 });
Winson Chungf0c6ae02012-03-21 16:10:31 -07003878 }
3879
Winson Chunga0b7e862013-09-05 16:03:15 -07003880 public boolean isAllAppsButtonRank(int rank) {
3881 if (mHotseat != null) {
3882 return mHotseat.isAllAppsButtonRank(rank);
3883 }
3884 return false;
3885 }
3886
Winson Chunga2413752012-04-03 14:22:34 -07003887 private boolean canRunNewAppsAnimation() {
3888 long diff = System.currentTimeMillis() - mDragController.getLastGestureUpTime();
3889 return diff > (NEW_APPS_ANIMATION_INACTIVE_TIMEOUT_SECONDS * 1000);
3890 }
3891
Winson Chungc9168342013-06-26 14:54:55 -07003892 private ValueAnimator createNewAppBounceAnimation(View v, int i) {
3893 ValueAnimator bounceAnim = LauncherAnimUtils.ofPropertyValuesHolder(v,
3894 PropertyValuesHolder.ofFloat("alpha", 1f),
3895 PropertyValuesHolder.ofFloat("scaleX", 1f),
3896 PropertyValuesHolder.ofFloat("scaleY", 1f));
3897 bounceAnim.setDuration(InstallShortcutReceiver.NEW_SHORTCUT_BOUNCE_DURATION);
3898 bounceAnim.setStartDelay(i * InstallShortcutReceiver.NEW_SHORTCUT_STAGGER_DELAY);
3899 bounceAnim.setInterpolator(new SmoothPagedView.OvershootInterpolator());
3900 return bounceAnim;
3901 }
3902
Narayan Kamathcb1a4772011-06-28 13:46:59 +01003903 @Override
3904 public void bindSearchablesChanged() {
Winson Chungc51db6a2011-10-05 11:44:49 -07003905 boolean searchVisible = updateGlobalSearchIcon();
3906 boolean voiceVisible = updateVoiceSearchIcon(searchVisible);
Winson Chungadf0c182012-08-23 14:59:07 -07003907 if (mSearchDropTargetBar != null) {
3908 mSearchDropTargetBar.onSearchPackagesChanged(searchVisible, voiceVisible);
3909 }
Narayan Kamathcb1a4772011-06-28 13:46:59 +01003910 }
3911
Amith Yamasani6d7fe502010-11-16 09:05:07 -08003912 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04003913 * Add the icons for all apps.
3914 *
3915 * Implementation of the method from LauncherModel.Callbacks.
3916 */
Michael Jurkaeadbfc52013-09-04 00:45:37 +02003917 public void bindAllApplications(final ArrayList<AppInfo> apps) {
Winson Chungc58497e2013-09-03 17:48:37 -07003918 if (AppsCustomizePagedView.DISABLE_ALL_APPS) {
3919 if (mIntentsOnWorkspaceFromUpgradePath != null) {
3920 if (LauncherModel.UPGRADE_USE_MORE_APPS_FOLDER) {
3921 getHotseat().addAllAppsFolder(mIconCache, apps,
3922 mIntentsOnWorkspaceFromUpgradePath, Launcher.this, mWorkspace);
3923 }
3924 mIntentsOnWorkspaceFromUpgradePath = null;
Daniel Sandler8707e0f2013-08-15 15:54:18 -07003925 }
Winson Chungc58497e2013-09-03 17:48:37 -07003926 } else {
3927 if (!AppsCustomizePagedView.DISABLE_ALL_APPS &&
3928 mAppsCustomizeContent != null) {
3929 mAppsCustomizeContent.setApps(apps);
3930 }
Winson Chung785d2eb2011-04-14 16:08:02 -07003931 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04003932 }
3933
Bjorn Bringert85f418d2013-09-06 12:50:05 +01003934 @Override
3935 public boolean shouldShowApp(ResolveInfo app) {
3936 return true;
3937 }
3938
Joe Onorato9c1289c2009-08-17 11:03:03 -04003939 /**
3940 * A package was updated.
3941 *
3942 * Implementation of the method from LauncherModel.Callbacks.
3943 */
Michael Jurkaeadbfc52013-09-04 00:45:37 +02003944 public void bindAppsUpdated(final ArrayList<AppInfo> apps) {
Winson Chungd64d1762013-08-20 14:37:16 -07003945 Runnable r = new Runnable() {
3946 public void run() {
3947 bindAppsUpdated(apps);
3948 }
3949 };
3950 if (waitUntilResume(r)) {
Michael Jurka7607c2f2013-04-03 14:33:19 -07003951 return;
3952 }
3953
Patrick Dubroyf5afda72011-02-28 12:04:18 -08003954 if (mWorkspace != null) {
3955 mWorkspace.updateShortcuts(apps);
3956 }
Winson Chungc58497e2013-09-03 17:48:37 -07003957
3958 if (!AppsCustomizePagedView.DISABLE_ALL_APPS &&
3959 mAppsCustomizeContent != null) {
3960 mAppsCustomizeContent.updateApps(apps);
3961 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04003962 }
3963
3964 /**
Winson Chung83892cc2013-05-01 16:53:33 -07003965 * A package was uninstalled. We take both the super set of packageNames
3966 * in addition to specific applications to remove, the reason being that
3967 * this can be called when a package is updated as well. In that scenario,
3968 * we only remove specific components from the workspace, where as
3969 * package-removal should clear all items by package name.
Joe Onorato9c1289c2009-08-17 11:03:03 -04003970 *
3971 * Implementation of the method from LauncherModel.Callbacks.
3972 */
Winson Chung83892cc2013-05-01 16:53:33 -07003973 public void bindComponentsRemoved(final ArrayList<String> packageNames,
Michael Jurkaeadbfc52013-09-04 00:45:37 +02003974 final ArrayList<AppInfo> appInfos,
Winson Chung64359a52013-07-08 17:17:08 -07003975 final boolean packageRemoved) {
Winson Chungd64d1762013-08-20 14:37:16 -07003976 Runnable r = new Runnable() {
Winson Chung83892cc2013-05-01 16:53:33 -07003977 public void run() {
Winson Chung64359a52013-07-08 17:17:08 -07003978 bindComponentsRemoved(packageNames, appInfos, packageRemoved);
Winson Chung83892cc2013-05-01 16:53:33 -07003979 }
Winson Chungd64d1762013-08-20 14:37:16 -07003980 };
3981 if (waitUntilResume(r)) {
Winson Chung83892cc2013-05-01 16:53:33 -07003982 return;
3983 }
3984
Winson Chung64359a52013-07-08 17:17:08 -07003985 if (packageRemoved) {
Winson Chung83892cc2013-05-01 16:53:33 -07003986 mWorkspace.removeItemsByPackageName(packageNames);
3987 } else {
3988 mWorkspace.removeItemsByApplicationInfo(appInfos);
Joe Onorato36115782010-06-17 13:28:48 -04003989 }
Winson Chungf0ea4d32011-06-06 14:27:16 -07003990
Winson Chunga1820962011-10-03 16:31:06 -07003991 // Notify the drag controller
Winson Chung83892cc2013-05-01 16:53:33 -07003992 mDragController.onAppsRemoved(appInfos, this);
Winson Chungc58497e2013-09-03 17:48:37 -07003993
3994 if (!AppsCustomizePagedView.DISABLE_ALL_APPS &&
3995 mAppsCustomizeContent != null) {
3996 mAppsCustomizeContent.removeApps(appInfos);
3997 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04003998 }
Joe Onoratobe386092009-11-17 17:32:16 -08003999
4000 /**
Winson Chung80baf5a2010-08-09 16:03:15 -07004001 * A number of packages were updated.
4002 */
Michael Jurkac402cd92013-05-20 15:49:32 +02004003 private ArrayList<Object> mWidgetsAndShortcuts;
4004 private Runnable mBindPackagesUpdatedRunnable = new Runnable() {
Winson Chung83892cc2013-05-01 16:53:33 -07004005 public void run() {
Michael Jurkac402cd92013-05-20 15:49:32 +02004006 bindPackagesUpdated(mWidgetsAndShortcuts);
4007 mWidgetsAndShortcuts = null;
Winson Chung83892cc2013-05-01 16:53:33 -07004008 }
Michael Jurkac402cd92013-05-20 15:49:32 +02004009 };
4010
4011 public void bindPackagesUpdated(final ArrayList<Object> widgetsAndShortcuts) {
4012 if (waitUntilResume(mBindPackagesUpdatedRunnable, true)) {
4013 mWidgetsAndShortcuts = widgetsAndShortcuts;
Winson Chung83892cc2013-05-01 16:53:33 -07004014 return;
4015 }
4016
Winson Chung64359a52013-07-08 17:17:08 -07004017 // Update the widgets pane
Winson Chungc58497e2013-09-03 17:48:37 -07004018 if (!AppsCustomizePagedView.DISABLE_ALL_APPS &&
4019 mAppsCustomizeContent != null) {
Michael Jurkac402cd92013-05-20 15:49:32 +02004020 mAppsCustomizeContent.onPackagesUpdated(widgetsAndShortcuts);
Winson Chung785d2eb2011-04-14 16:08:02 -07004021 }
Winson Chung80baf5a2010-08-09 16:03:15 -07004022 }
4023
Winson Chung400438b2011-01-16 17:53:48 -08004024 private int mapConfigurationOriActivityInfoOri(int configOri) {
4025 final Display d = getWindowManager().getDefaultDisplay();
4026 int naturalOri = Configuration.ORIENTATION_LANDSCAPE;
4027 switch (d.getRotation()) {
4028 case Surface.ROTATION_0:
4029 case Surface.ROTATION_180:
4030 // We are currently in the same basic orientation as the natural orientation
4031 naturalOri = configOri;
4032 break;
4033 case Surface.ROTATION_90:
4034 case Surface.ROTATION_270:
4035 // We are currently in the other basic orientation to the natural orientation
4036 naturalOri = (configOri == Configuration.ORIENTATION_LANDSCAPE) ?
4037 Configuration.ORIENTATION_PORTRAIT : Configuration.ORIENTATION_LANDSCAPE;
4038 break;
4039 }
4040
4041 int[] oriMap = {
4042 ActivityInfo.SCREEN_ORIENTATION_PORTRAIT,
4043 ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE,
4044 ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT,
4045 ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
4046 };
4047 // Since the map starts at portrait, we need to offset if this device's natural orientation
4048 // is landscape.
4049 int indexOffset = 0;
4050 if (naturalOri == Configuration.ORIENTATION_LANDSCAPE) {
4051 indexOffset = 1;
4052 }
4053 return oriMap[(d.getRotation() + indexOffset) % 4];
4054 }
Adam Cohen446e9402011-09-15 18:21:21 -07004055
Winson Chung4b919f82012-05-01 10:44:08 -07004056 public boolean isRotationEnabled() {
Michael Jurka0a457bf2012-11-19 14:05:05 -08004057 boolean enableRotation = sForceEnableRotation ||
Winson Chung4b919f82012-05-01 10:44:08 -07004058 getResources().getBoolean(R.bool.allow_rotation);
4059 return enableRotation;
Winson Chung400438b2011-01-16 17:53:48 -08004060 }
Winson Chung4b919f82012-05-01 10:44:08 -07004061 public void lockScreenOrientation() {
4062 if (isRotationEnabled()) {
4063 setRequestedOrientation(mapConfigurationOriActivityInfoOri(getResources()
4064 .getConfiguration().orientation));
4065 }
4066 }
4067 public void unlockScreenOrientation(boolean immediate) {
4068 if (isRotationEnabled()) {
4069 if (immediate) {
Winson Chung641d71d2012-04-26 15:58:01 -07004070 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
Winson Chung4b919f82012-05-01 10:44:08 -07004071 } else {
4072 mHandler.postDelayed(new Runnable() {
4073 public void run() {
4074 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
4075 }
4076 }, mRestoreScreenOrientationDelay);
Winson Chung641d71d2012-04-26 15:58:01 -07004077 }
Winson Chung4b919f82012-05-01 10:44:08 -07004078 }
Winson Chung400438b2011-01-16 17:53:48 -08004079 }
4080
Winson Chung82f55532011-08-09 14:14:23 -07004081 /* Cling related */
Winson Chung7d7541e2011-09-16 20:14:36 -07004082 private boolean isClingsEnabled() {
Adam Cohen7564d982013-06-06 23:11:58 -07004083 if (DISABLE_CLINGS) {
4084 return false;
4085 }
4086
Brett Chabot2a9e2282011-08-23 15:03:13 -07004087 // disable clings when running in a test harness
Winson Chung7d7541e2011-09-16 20:14:36 -07004088 if(ActivityManager.isRunningInTestHarness()) return false;
Brett Chabot2a9e2282011-08-23 15:03:13 -07004089
Michael Jurkae233a8b2013-03-19 13:49:20 +01004090 // Restricted secondary users (child mode) will potentially have very few apps
4091 // seeded when they start up for the first time. Clings won't work well with that
Daniel Sandler325dc232013-06-05 22:57:57 -04004092// boolean supportsLimitedUsers =
4093// android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN_MR2;
4094// Account[] accounts = AccountManager.get(this).getAccounts();
4095// if (supportsLimitedUsers && accounts.length == 0) {
4096// UserManager um = (UserManager) getSystemService(Context.USER_SERVICE);
4097// Bundle restrictions = um.getUserRestrictions();
4098// if (restrictions.getBoolean(UserManager.DISALLOW_MODIFY_ACCOUNTS, false)) {
4099// return false;
4100// }
4101// }
Winson Chung7d7541e2011-09-16 20:14:36 -07004102 return true;
Winson Chung82f55532011-08-09 14:14:23 -07004103 }
Michael Jurka22143132012-10-04 17:42:38 +02004104
Winson Chungfa545132013-09-26 17:45:32 -07004105 private Cling initCling(int clingId, int scrimId, boolean animate,
Winson Chungaf40f202013-09-18 18:26:31 -07004106 boolean dimNavBarVisibilty) {
Winson Chungfa545132013-09-26 17:45:32 -07004107 Cling cling = (Cling) findViewById(clingId);
4108 View scrim = null;
4109 if (scrimId > 0) {
Sandeep Siddharthaa6125ef2013-09-26 20:30:40 -07004110 scrim = findViewById(R.id.cling_scrim);
Winson Chungfa545132013-09-26 17:45:32 -07004111 }
Winson Chung7d7541e2011-09-16 20:14:36 -07004112 if (cling != null) {
Winson Chungfa545132013-09-26 17:45:32 -07004113 cling.init(this, scrim);
Winson Chungaf40f202013-09-18 18:26:31 -07004114 cling.show(animate, SHOW_CLING_DURATION);
4115
4116 if (dimNavBarVisibilty) {
4117 cling.setSystemUiVisibility(cling.getSystemUiVisibility() |
4118 View.SYSTEM_UI_FLAG_LOW_PROFILE);
Winson Chung7d7541e2011-09-16 20:14:36 -07004119 }
4120 }
4121 return cling;
4122 }
Michael Jurka22143132012-10-04 17:42:38 +02004123
Winson Chungaf40f202013-09-18 18:26:31 -07004124 private void dismissCling(final Cling cling, final Runnable postAnimationCb,
4125 final String flag, int duration, boolean restoreNavBarVisibilty) {
Winson Chung7819abd2012-11-29 14:29:38 -08004126 // To catch cases where siblings of top-level views are made invisible, just check whether
4127 // the cling is directly set to GONE before dismissing it.
4128 if (cling != null && cling.getVisibility() != View.GONE) {
Winson Chungaf40f202013-09-18 18:26:31 -07004129 final Runnable cleanUpClingCb = new Runnable() {
4130 public void run() {
Winson Chung82f55532011-08-09 14:14:23 -07004131 cling.cleanup();
Winson Chung46353de2012-02-16 14:05:10 -08004132 // We should update the shared preferences on a background thread
4133 new Thread("dismissClingThread") {
4134 public void run() {
4135 SharedPreferences.Editor editor = mSharedPrefs.edit();
4136 editor.putBoolean(flag, true);
4137 editor.commit();
4138 }
4139 }.start();
Winson Chungaf40f202013-09-18 18:26:31 -07004140 if (postAnimationCb != null) {
4141 postAnimationCb.run();
4142 }
4143 }
4144 };
4145 if (duration <= 0) {
4146 cleanUpClingCb.run();
4147 } else {
4148 cling.hide(duration, cleanUpClingCb);
4149 }
Michael Jurka22143132012-10-04 17:42:38 +02004150 mHideFromAccessibilityHelper.restoreImportantForAccessibility(mDragLayer);
Winson Chungaf40f202013-09-18 18:26:31 -07004151
4152 if (restoreNavBarVisibilty) {
4153 cling.setSystemUiVisibility(cling.getSystemUiVisibility() &
4154 ~View.SYSTEM_UI_FLAG_LOW_PROFILE);
4155 }
Winson Chung82f55532011-08-09 14:14:23 -07004156 }
4157 }
Michael Jurka22143132012-10-04 17:42:38 +02004158
Winson Chung9d9d74f2011-09-19 11:49:12 -07004159 private void removeCling(int id) {
4160 final View cling = findViewById(id);
4161 if (cling != null) {
4162 final ViewGroup parent = (ViewGroup) cling.getParent();
4163 parent.post(new Runnable() {
4164 @Override
4165 public void run() {
4166 parent.removeView(cling);
4167 }
4168 });
Michael Jurka22143132012-10-04 17:42:38 +02004169 mHideFromAccessibilityHelper.restoreImportantForAccessibility(mDragLayer);
Winson Chung9d9d74f2011-09-19 11:49:12 -07004170 }
4171 }
Michael Jurka974c3862012-05-22 22:00:31 -07004172
4173 private boolean skipCustomClingIfNoAccounts() {
4174 Cling cling = (Cling) findViewById(R.id.workspace_cling);
4175 boolean customCling = cling.getDrawIdentifier().equals("workspace_custom");
4176 if (customCling) {
4177 AccountManager am = AccountManager.get(this);
Daniel Sandler325dc232013-06-05 22:57:57 -04004178 if (am == null) return false;
Michael Jurka974c3862012-05-22 22:00:31 -07004179 Account[] accounts = am.getAccountsByType("com.google");
4180 return accounts.length == 0;
4181 }
4182 return false;
4183 }
4184
Winson Chungaf40f202013-09-18 18:26:31 -07004185 public void showFirstRunCling() {
Winson Chung46353de2012-02-16 14:05:10 -08004186 if (isClingsEnabled() &&
Winson Chungaf40f202013-09-18 18:26:31 -07004187 !mSharedPrefs.getBoolean(Cling.FIRST_RUN_CLING_DISMISSED_KEY, false) &&
Michael Jurka974c3862012-05-22 22:00:31 -07004188 !skipCustomClingIfNoAccounts() ) {
Michael Jurka45355c42012-10-08 13:21:35 +02004189 // If we're not using the default workspace layout, replace workspace cling
4190 // with a custom workspace cling (usually specified in an overlay)
4191 // For now, only do this on tablets
Winson Chunge6eabff2013-09-24 11:01:23 -07004192 if (!DISABLE_CUSTOM_CLINGS) {
4193 if (mSharedPrefs.getInt(LauncherProvider.DEFAULT_WORKSPACE_RESOURCE_ID, 0) != 0 &&
4194 getResources().getBoolean(R.bool.config_useCustomClings)) {
4195 // Use a custom cling
4196 View cling = findViewById(R.id.workspace_cling);
4197 ViewGroup clingParent = (ViewGroup) cling.getParent();
4198 int clingIndex = clingParent.indexOfChild(cling);
4199 clingParent.removeViewAt(clingIndex);
4200 View customCling = mInflater.inflate(R.layout.custom_workspace_cling, clingParent, false);
4201 clingParent.addView(customCling, clingIndex);
4202 customCling.setId(R.id.workspace_cling);
4203 }
4204 }
4205 Cling cling = (Cling) findViewById(R.id.first_run_cling);
4206 if (cling != null) {
4207 String sbHintStr = getFirstRunClingSearchBarHint();
4208 String ccHintStr = getFirstRunCustomContentHint();
4209 if (!sbHintStr.isEmpty()) {
4210 TextView sbHint = (TextView) cling.findViewById(R.id.search_bar_hint);
4211 sbHint.setText(sbHintStr);
4212 sbHint.setVisibility(View.VISIBLE);
4213 }
4214 if (!ccHintStr.isEmpty()) {
4215 TextView ccHint = (TextView) cling.findViewById(R.id.custom_content_hint);
4216 ccHint.setText(ccHintStr);
4217 ccHint.setVisibility(View.VISIBLE);
4218 }
Michael Jurka45355c42012-10-08 13:21:35 +02004219 }
Winson Chungfa545132013-09-26 17:45:32 -07004220 initCling(R.id.first_run_cling, 0, false, true);
Winson Chung9d9d74f2011-09-19 11:49:12 -07004221 } else {
Winson Chungaf40f202013-09-18 18:26:31 -07004222 removeCling(R.id.first_run_cling);
Winson Chung7d7541e2011-09-16 20:14:36 -07004223 }
4224 }
Winson Chungaf40f202013-09-18 18:26:31 -07004225
Winson Chunge6eabff2013-09-24 11:01:23 -07004226 protected String getFirstRunClingSearchBarHint() {
4227 return "";
4228 }
4229 protected String getFirstRunCustomContentHint() {
4230 return "";
4231 }
4232
Winson Chungaf40f202013-09-18 18:26:31 -07004233 public void showFirstRunWorkspaceCling() {
Winson Chung7d7541e2011-09-16 20:14:36 -07004234 // Enable the clings only if they have not been dismissed before
Winson Chung46353de2012-02-16 14:05:10 -08004235 if (isClingsEnabled() &&
Winson Chungaf40f202013-09-18 18:26:31 -07004236 !mSharedPrefs.getBoolean(Cling.WORKSPACE_CLING_DISMISSED_KEY, false)) {
Winson Chungfa545132013-09-26 17:45:32 -07004237 initCling(R.id.workspace_cling, 0, false, true);
Winson Chung9d9d74f2011-09-19 11:49:12 -07004238 } else {
Winson Chungaf40f202013-09-18 18:26:31 -07004239 removeCling(R.id.workspace_cling);
Winson Chung7d7541e2011-09-16 20:14:36 -07004240 }
4241 }
4242 public Cling showFirstRunFoldersCling() {
Winson Chung7d7541e2011-09-16 20:14:36 -07004243 // Enable the clings only if they have not been dismissed before
Winson Chung46353de2012-02-16 14:05:10 -08004244 if (isClingsEnabled() &&
4245 !mSharedPrefs.getBoolean(Cling.FOLDER_CLING_DISMISSED_KEY, false)) {
Winson Chungfa545132013-09-26 17:45:32 -07004246 Cling cling = initCling(R.id.folder_cling, R.id.cling_scrim,
4247 true, true);
Winson Chungaf40f202013-09-18 18:26:31 -07004248 return cling;
Winson Chung9d9d74f2011-09-19 11:49:12 -07004249 } else {
4250 removeCling(R.id.folder_cling);
Winson Chung46353de2012-02-16 14:05:10 -08004251 return null;
Winson Chung7d7541e2011-09-16 20:14:36 -07004252 }
Winson Chung7d7541e2011-09-16 20:14:36 -07004253 }
Michael Jurka104c4562013-07-08 18:03:46 -07004254 protected SharedPreferences getSharedPrefs() {
4255 return mSharedPrefs;
4256 }
Winson Chung7d7541e2011-09-16 20:14:36 -07004257 public boolean isFolderClingVisible() {
4258 Cling cling = (Cling) findViewById(R.id.folder_cling);
Winson Chung9d9d74f2011-09-19 11:49:12 -07004259 if (cling != null) {
4260 return cling.getVisibility() == View.VISIBLE;
4261 }
4262 return false;
Winson Chung7d7541e2011-09-16 20:14:36 -07004263 }
Winson Chungaf40f202013-09-18 18:26:31 -07004264 public void dismissFirstRunCling(View v) {
4265 Cling cling = (Cling) findViewById(R.id.first_run_cling);
4266 Runnable cb = new Runnable() {
4267 public void run() {
4268 // Show the workspace cling next
4269 showFirstRunWorkspaceCling();
4270 }
4271 };
4272 dismissCling(cling, cb, Cling.FIRST_RUN_CLING_DISMISSED_KEY,
4273 DISMISS_CLING_DURATION, false);
4274 }
Winson Chung82f55532011-08-09 14:14:23 -07004275 public void dismissWorkspaceCling(View v) {
4276 Cling cling = (Cling) findViewById(R.id.workspace_cling);
Winson Chungaf40f202013-09-18 18:26:31 -07004277 Runnable cb = null;
4278 if (v == null) {
4279 cb = new Runnable() {
4280 public void run() {
4281 mWorkspace.enterOverviewMode();
4282 }
4283 };
4284 }
4285 dismissCling(cling, cb, Cling.WORKSPACE_CLING_DISMISSED_KEY,
4286 DISMISS_CLING_DURATION, true);
Winson Chung7d7541e2011-09-16 20:14:36 -07004287 }
4288 public void dismissFolderCling(View v) {
4289 Cling cling = (Cling) findViewById(R.id.folder_cling);
Winson Chungaf40f202013-09-18 18:26:31 -07004290 dismissCling(cling, null, Cling.FOLDER_CLING_DISMISSED_KEY,
4291 DISMISS_CLING_DURATION, true);
Winson Chung82f55532011-08-09 14:14:23 -07004292 }
4293
Winson Chung80baf5a2010-08-09 16:03:15 -07004294 /**
Joe Onoratobe386092009-11-17 17:32:16 -08004295 * Prints out out state for debugging.
4296 */
4297 public void dumpState() {
Daniel Sandler325dc232013-06-05 22:57:57 -04004298 Log.d(TAG, "BEGIN launcher3 dump state for launcher " + this);
Joe Onorato39bfc132009-11-18 17:22:01 -08004299 Log.d(TAG, "mSavedState=" + mSavedState);
Joe Onorato39bfc132009-11-18 17:22:01 -08004300 Log.d(TAG, "mWorkspaceLoading=" + mWorkspaceLoading);
4301 Log.d(TAG, "mRestoring=" + mRestoring);
4302 Log.d(TAG, "mWaitingForResult=" + mWaitingForResult);
4303 Log.d(TAG, "mSavedInstanceState=" + mSavedInstanceState);
Brad Fitzpatrick319226a2010-09-01 13:45:16 -07004304 Log.d(TAG, "sFolders.size=" + sFolders.size());
Joe Onoratobe386092009-11-17 17:32:16 -08004305 mModel.dumpState();
Winson Chungf0ea4d32011-06-06 14:27:16 -07004306
Winson Chung785d2eb2011-04-14 16:08:02 -07004307 if (mAppsCustomizeContent != null) {
4308 mAppsCustomizeContent.dumpState();
4309 }
Daniel Sandler325dc232013-06-05 22:57:57 -04004310 Log.d(TAG, "END launcher3 dump state");
Joe Onoratobe386092009-11-17 17:32:16 -08004311 }
Adam Cohen16d7ffc2011-10-05 17:49:14 -07004312
4313 @Override
4314 public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) {
4315 super.dump(prefix, fd, writer, args);
Adam Cohen4caf2982013-08-20 18:54:31 -07004316 synchronized (sDumpLogs) {
4317 writer.println(" ");
4318 writer.println("Debug logs: ");
4319 for (int i = 0; i < sDumpLogs.size(); i++) {
4320 writer.println(" " + sDumpLogs.get(i));
4321 }
Adam Cohen16d7ffc2011-10-05 17:49:14 -07004322 }
4323 }
Adam Cohen487f7dd2012-06-28 18:12:10 -07004324
4325 public static void dumpDebugLogsToConsole() {
Winson Chungede41292013-09-19 16:27:36 -07004326 if (DEBUG_DUMP_LOG) {
4327 synchronized (sDumpLogs) {
4328 Log.d(TAG, "");
4329 Log.d(TAG, "*********************");
4330 Log.d(TAG, "Launcher debug logs: ");
4331 for (int i = 0; i < sDumpLogs.size(); i++) {
4332 Log.d(TAG, " " + sDumpLogs.get(i));
4333 }
4334 Log.d(TAG, "*********************");
4335 Log.d(TAG, "");
Adam Cohen4caf2982013-08-20 18:54:31 -07004336 }
Adam Cohen487f7dd2012-06-28 18:12:10 -07004337 }
Adam Cohen4caf2982013-08-20 18:54:31 -07004338 }
4339
4340 public static void addDumpLog(String tag, String log, boolean debugLog) {
4341 if (debugLog) {
4342 Log.d(tag, log);
4343 }
Winson Chungede41292013-09-19 16:27:36 -07004344 if (DEBUG_DUMP_LOG) {
4345 sDateStamp.setTime(System.currentTimeMillis());
4346 synchronized (sDumpLogs) {
4347 sDumpLogs.add(sDateFormat.format(sDateStamp) + ": " + tag + ", " + log);
Adam Cohen4caf2982013-08-20 18:54:31 -07004348 }
Winson Chungede41292013-09-19 16:27:36 -07004349 }
Adam Cohen4caf2982013-08-20 18:54:31 -07004350 }
4351
Winson Chungede41292013-09-19 16:27:36 -07004352 public void dumpLogsToLocalData() {
4353 if (DEBUG_DUMP_LOG) {
4354 new Thread("DumpLogsToLocalData") {
4355 @Override
4356 public void run() {
4357 boolean success = false;
4358 sDateStamp.setTime(sRunStart);
4359 String FILENAME = sDateStamp.getMonth() + "-"
4360 + sDateStamp.getDay() + "_"
4361 + sDateStamp.getHours() + "-"
4362 + sDateStamp.getMinutes() + "_"
4363 + sDateStamp.getSeconds() + ".txt";
4364
4365 FileOutputStream fos = null;
4366 File outFile = null;
4367 try {
4368 outFile = new File(getFilesDir(), FILENAME);
4369 outFile.createNewFile();
4370 fos = new FileOutputStream(outFile);
4371 } catch (Exception e) {
4372 e.printStackTrace();
4373 }
4374 if (fos != null) {
4375 PrintWriter writer = new PrintWriter(fos);
4376
4377 writer.println(" ");
4378 writer.println("Debug logs: ");
4379 synchronized (sDumpLogs) {
4380 for (int i = 0; i < sDumpLogs.size(); i++) {
4381 writer.println(" " + sDumpLogs.get(i));
4382 }
4383 }
4384 writer.close();
4385 }
4386 try {
4387 if (fos != null) {
4388 fos.close();
4389 success = true;
4390 }
4391 } catch (IOException e) {
4392 e.printStackTrace();
4393 }
4394 }
4395 }.start();
Adam Cohen4caf2982013-08-20 18:54:31 -07004396 }
Adam Cohen487f7dd2012-06-28 18:12:10 -07004397 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08004398}
Michael Jurka2763be32011-02-24 11:19:57 -08004399
Michael Jurkaabded662011-03-04 12:06:57 -08004400interface LauncherTransitionable {
Michael Jurka2a4b1a82011-12-07 14:00:02 -08004401 View getContent();
Michael Jurkaa35e35a2012-04-26 15:04:28 -07004402 void onLauncherTransitionPrepare(Launcher l, boolean animated, boolean toWorkspace);
Michael Jurkabed61d22012-02-14 22:51:29 -08004403 void onLauncherTransitionStart(Launcher l, boolean animated, boolean toWorkspace);
Winson Chung70442722012-02-10 15:43:22 -08004404 void onLauncherTransitionStep(Launcher l, float t);
Michael Jurkabed61d22012-02-14 22:51:29 -08004405 void onLauncherTransitionEnd(Launcher l, boolean animated, boolean toWorkspace);
Michael Jurka2763be32011-02-24 11:19:57 -08004406}