blob: 86b4f94605e4e3eaba1acbc0ac5231d41c5df30b [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
Gilles Debunnedd6c9922010-10-25 11:23:41 -070020import android.animation.Animator;
Michael Jurka8edd75c2010-12-17 20:15:06 -080021import android.animation.AnimatorListenerAdapter;
Gilles Debunnedd6c9922010-10-25 11:23:41 -070022import android.animation.AnimatorSet;
Adam Cohen2801caf2011-05-13 20:57:39 -070023import android.animation.ObjectAnimator;
24import android.animation.PropertyValuesHolder;
Gilles Debunnedd6c9922010-10-25 11:23:41 -070025import android.animation.ValueAnimator;
Winson Chung70442722012-02-10 15:43:22 -080026import android.animation.ValueAnimator.AnimatorUpdateListener;
Michael Jurka946ad472010-07-09 18:05:18 -070027import android.app.Activity;
Brett Chabot2a9e2282011-08-23 15:03:13 -070028import android.app.ActivityManager;
Winson Chungc7450e32012-04-17 17:34:08 -070029import android.app.ActivityOptions;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080030import android.app.SearchManager;
Adam Cohen0cf2a7c2011-11-08 15:07:01 -080031import android.appwidget.AppWidgetHostView;
Michael Jurkaaf442092010-06-10 17:01:57 -070032import android.appwidget.AppWidgetManager;
33import android.appwidget.AppWidgetProviderInfo;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080034import android.content.ActivityNotFoundException;
Joe Onorato2ca0ae72009-11-10 13:14:13 -080035import android.content.BroadcastReceiver;
Michael Jurkae326f182011-11-21 14:05:46 -080036import android.content.ComponentCallbacks2;
Daniel Sandlerc9b18772010-04-22 14:37:59 -040037import android.content.ComponentName;
Jeff Sharkey1e2efc82009-11-06 15:17:59 -080038import android.content.ContentResolver;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080039import android.content.Context;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080040import android.content.Intent;
Winson Chungf0ea4d32011-06-06 14:27:16 -070041import android.content.IntentFilter;
Winson Chung82f55532011-08-09 14:14:23 -070042import android.content.SharedPreferences;
Winson Chungaafa03c2010-06-11 17:34:16 -070043import android.content.pm.ActivityInfo;
Winson Chunge43a1e72014-01-15 10:33:02 -080044import android.content.pm.ApplicationInfo;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080045import android.content.pm.PackageManager;
Adam Cohen716b51e2011-06-30 12:09:54 -070046import android.content.pm.PackageManager.NameNotFoundException;
Mathew Inwood72fbec12013-11-19 15:45:07 +000047import android.content.pm.ResolveInfo;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080048import android.content.res.Configuration;
Karl Rosaen138a0412009-04-23 19:00:21 -070049import android.content.res.Resources;
Jeff Sharkey1e2efc82009-11-06 15:17:59 -080050import android.database.ContentObserver;
Adam Cohen268c4752012-06-06 17:47:33 -070051import android.graphics.Bitmap;
52import android.graphics.Canvas;
Winson Chung5f8afe62013-08-12 16:19:28 -070053import android.graphics.Point;
Adam Cohen268c4752012-06-06 17:47:33 -070054import android.graphics.PorterDuff;
Michael Jurkaaf442092010-06-10 17:01:57 -070055import android.graphics.Rect;
Michael Jurkaaf442092010-06-10 17:01:57 -070056import android.graphics.drawable.Drawable;
Daniel Sandlerc9b18772010-04-22 14:37:59 -040057import android.net.Uri;
Brad Fitzpatrick319226a2010-09-01 13:45:16 -070058import android.os.AsyncTask;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080059import android.os.Bundle;
Christian Mehlmauer0fbe7bc2010-08-02 20:27:46 +020060import android.os.Environment;
Jeff Sharkey1e2efc82009-11-06 15:17:59 -080061import android.os.Handler;
Adam Cohended9f8d2010-11-03 13:25:16 -070062import android.os.Message;
Winson Chunga2413752012-04-03 14:22:34 -070063import android.os.StrictMode;
Daniel Sandler843e8602010-06-07 14:59:01 -040064import android.os.SystemClock;
Patrick Dubroy4ed62782010-08-17 15:11:18 -070065import android.provider.Settings;
Amith Yamasani6d7fe502010-11-16 09:05:07 -080066import android.speech.RecognizerIntent;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080067import android.text.Selection;
68import android.text.SpannableStringBuilder;
Michael Jurkaa33411c2012-06-14 16:18:21 -070069import android.text.TextUtils;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080070import android.text.method.TextKeyListener;
Winson Chung892c74d2013-08-22 16:15:50 -070071import android.util.DisplayMetrics;
Joe Onorato7c312c12009-08-13 21:36:53 -070072import android.util.Log;
Adam Cohen96d30a12013-07-16 18:13:21 -070073import android.view.Display;
74import android.view.Gravity;
75import android.view.HapticFeedbackConstants;
76import android.view.KeyEvent;
77import android.view.LayoutInflater;
78import android.view.Menu;
Adam Cohen96d30a12013-07-16 18:13:21 -070079import android.view.MotionEvent;
80import android.view.Surface;
81import android.view.View;
Adam Cohenf358a4b2013-07-23 16:47:31 -070082import android.view.View.OnClickListener;
Adam Cohen0cf2a7c2011-11-08 15:07:01 -080083import android.view.View.OnLongClickListener;
Adam Cohen96d30a12013-07-16 18:13:21 -070084import android.view.ViewGroup;
85import android.view.ViewTreeObserver;
Michael Jurka2a4b1a82011-12-07 14:00:02 -080086import android.view.ViewTreeObserver.OnGlobalLayoutListener;
Adam Cohen96d30a12013-07-16 18:13:21 -070087import android.view.WindowManager;
Svetoslav Ganov815ba2d2011-01-07 14:55:17 -080088import android.view.accessibility.AccessibilityEvent;
Adam Cohencff6af82011-09-13 14:51:53 -070089import android.view.animation.AccelerateDecelerateInterpolator;
Adam Cohenf16e5712011-01-13 13:31:45 -080090import android.view.animation.DecelerateInterpolator;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080091import android.view.inputmethod.InputMethodManager;
Adam Cohen96d30a12013-07-16 18:13:21 -070092import android.widget.Advanceable;
93import android.widget.FrameLayout;
94import android.widget.ImageView;
95import android.widget.TextView;
96import android.widget.Toast;
Patrick Dubroy4ed62782010-08-17 15:11:18 -070097
Daniel Sandler325dc232013-06-05 22:57:57 -040098import com.android.launcher3.DropTarget.DragObject;
Romain Guyedcce092010-03-04 13:03:17 -080099
Adam Cohenc0dcf592011-06-01 15:30:43 -0700100import java.io.DataInputStream;
101import java.io.DataOutputStream;
Adam Cohen4caf2982013-08-20 18:54:31 -0700102import java.io.File;
Adam Cohen16d7ffc2011-10-05 17:49:14 -0700103import java.io.FileDescriptor;
Adam Cohenc0dcf592011-06-01 15:30:43 -0700104import java.io.FileNotFoundException;
Adam Cohen4caf2982013-08-20 18:54:31 -0700105import java.io.FileOutputStream;
Adam Cohenc0dcf592011-06-01 15:30:43 -0700106import java.io.IOException;
Adam Cohen16d7ffc2011-10-05 17:49:14 -0700107import java.io.PrintWriter;
Adam Cohen4caf2982013-08-20 18:54:31 -0700108import java.text.DateFormat;
Adam Cohenc0dcf592011-06-01 15:30:43 -0700109import java.util.ArrayList;
Winson Chungf0c6ae02012-03-21 16:10:31 -0700110import java.util.Collection;
Adam Cohen4caf2982013-08-20 18:54:31 -0700111import java.util.Date;
Adam Cohenc0dcf592011-06-01 15:30:43 -0700112import java.util.HashMap;
Michael Jurkad7c28052012-04-27 15:43:36 -0700113import java.util.List;
Adam Cohenc76e1dd2013-11-14 11:09:14 +0000114import java.util.concurrent.atomic.AtomicInteger;
Adam Cohenc0dcf592011-06-01 15:30:43 -0700115
Winson Chunga6945242014-01-08 14:04:34 -0800116
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800117/**
118 * Default launcher application.
119 */
Bjorn Bringertc459e522013-06-07 19:36:01 +0100120public class Launcher extends Activity
Michael Jurka0e260592010-06-30 17:07:39 -0700121 implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks,
Winson Chungcd810732012-06-18 16:45:43 -0700122 View.OnTouchListener {
Joe Onoratoa30ce8e2009-11-11 08:16:49 -0800123 static final String TAG = "Launcher";
Joe Onoratocc67f472010-06-08 10:54:30 -0700124 static final boolean LOGD = false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800125
Daniel Sandlerf061f822013-06-27 13:59:36 -0400126 static final boolean PROFILE_STARTUP = false;
Daniel Sandler843e8602010-06-07 14:59:01 -0400127 static final boolean DEBUG_WIDGETS = false;
Winson Chunga2413752012-04-03 14:22:34 -0700128 static final boolean DEBUG_STRICT_MODE = false;
Daniel Sandlerf061f822013-06-27 13:59:36 -0400129 static final boolean DEBUG_RESUME_TIME = false;
Winson Chungede41292013-09-19 16:27:36 -0700130 static final boolean DEBUG_DUMP_LOG = false;
Romain Guy6fefcf12009-06-11 13:07:43 -0700131
Dan Sandlerd5024042014-01-09 15:01:33 -0500132 static final boolean ENABLE_DEBUG_INTENTS = false; // allow DebugIntents to run
133
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800134 private static final int REQUEST_CREATE_SHORTCUT = 1;
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700135 private static final int REQUEST_CREATE_APPWIDGET = 5;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800136 private static final int REQUEST_PICK_APPLICATION = 6;
137 private static final int REQUEST_PICK_SHORTCUT = 7;
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700138 private static final int REQUEST_PICK_APPWIDGET = 9;
Mike Clerona0618e42009-10-22 13:55:21 -0700139 private static final int REQUEST_PICK_WALLPAPER = 10;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800140
Michael Jurka8b805b12012-04-18 14:23:14 -0700141 private static final int REQUEST_BIND_APPWIDGET = 11;
142
Mathew Inwood876a8462013-06-14 14:12:41 +0100143 /**
144 * IntentStarter uses request codes starting with this. This must be greater than all activity
145 * request codes used internally.
146 */
147 protected static final int REQUEST_LAST = 100;
148
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800149 static final String EXTRA_SHORTCUT_DUPLICATE = "duplicate";
150
Mike Cleron3a2b3f22009-11-05 17:17:42 -0800151 static final int SCREEN_COUNT = 5;
152 static final int DEFAULT_SCREEN = 2;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800153
Romain Guy98d01652009-06-30 16:21:04 -0700154 private static final String PREFERENCES = "launcher.preferences";
Michael Jurka0a457bf2012-11-19 14:05:05 -0800155 // To turn on these properties, type
156 // adb shell setprop log.tag.PROPERTY_NAME [VERBOSE | SUPPRESS]
157 static final String FORCE_ENABLE_ROTATION_PROPERTY = "launcher_force_rotate";
158 static final String DUMP_STATE_PROPERTY = "launcher_dump_state";
Nilesh Agrawal16f3ea82014-01-09 17:14:01 -0800159 static final String DISABLE_ALL_APPS_PROPERTY = "launcher_noallapps";
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800160
Winson Chung2672ff92012-05-04 16:22:30 -0700161 // The Intent extra that defines whether to ignore the launch animation
162 static final String INTENT_EXTRA_IGNORE_LAUNCH_ANIMATION =
Daniel Sandler325dc232013-06-05 22:57:57 -0400163 "com.android.launcher3.intent.extra.shortcut.INGORE_LAUNCH_ANIMATION";
Winson Chung2672ff92012-05-04 16:22:30 -0700164
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800165 // Type: int
166 private static final String RUNTIME_STATE_CURRENT_SCREEN = "launcher.current_screen";
Michael Jurka883f55b2010-10-21 15:47:14 -0700167 // Type: int
168 private static final String RUNTIME_STATE = "launcher.state";
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800169 // Type: int
Winson Chung3d503fb2011-07-13 17:25:49 -0700170 private static final String RUNTIME_STATE_PENDING_ADD_CONTAINER = "launcher.add_container";
171 // Type: int
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800172 private static final String RUNTIME_STATE_PENDING_ADD_SCREEN = "launcher.add_screen";
173 // Type: int
Adam Cohenfbba09b2011-07-18 21:43:05 -0700174 private static final String RUNTIME_STATE_PENDING_ADD_CELL_X = "launcher.add_cell_x";
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800175 // Type: int
Adam Cohenfbba09b2011-07-18 21:43:05 -0700176 private static final String RUNTIME_STATE_PENDING_ADD_CELL_Y = "launcher.add_cell_y";
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800177 // Type: boolean
178 private static final String RUNTIME_STATE_PENDING_FOLDER_RENAME = "launcher.rename_folder";
179 // Type: long
180 private static final String RUNTIME_STATE_PENDING_FOLDER_RENAME_ID = "launcher.rename_folder_id";
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700181 // Type: int
182 private static final String RUNTIME_STATE_PENDING_ADD_SPAN_X = "launcher.add_span_x";
183 // Type: int
184 private static final String RUNTIME_STATE_PENDING_ADD_SPAN_Y = "launcher.add_span_y";
185 // Type: parcelable
186 private static final String RUNTIME_STATE_PENDING_ADD_WIDGET_INFO = "launcher.add_widget_info";
Adam Cohenc76e1dd2013-11-14 11:09:14 +0000187 // Type: parcelable
Adam Cohen4637b5a2013-11-04 18:21:24 -0800188 private static final String RUNTIME_STATE_PENDING_ADD_WIDGET_ID = "launcher.add_widget_id";
Adam Cohenc76e1dd2013-11-14 11:09:14 +0000189 // Type: int[]
190 private static final String RUNTIME_STATE_VIEW_IDS = "launcher.view_ids";
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800191
Adam Cohenb54a5982014-01-08 15:21:04 -0800192
193 static final String FIRST_RUN_ACTIVITY_DISPLAYED = "launcher.first_run_activity_displayed";
194
Bjorn Bringerte441bbc2013-06-06 21:54:20 +0100195 private static final String TOOLBAR_ICON_METADATA_NAME = "com.android.launcher.toolbar_icon";
Michael Jurkaae65ee32012-04-30 11:45:54 -0700196 private static final String TOOLBAR_SEARCH_ICON_METADATA_NAME =
Bjorn Bringerte441bbc2013-06-06 21:54:20 +0100197 "com.android.launcher.toolbar_search_icon";
Michael Jurkaae65ee32012-04-30 11:45:54 -0700198 private static final String TOOLBAR_VOICE_SEARCH_ICON_METADATA_NAME =
Bjorn Bringerte441bbc2013-06-06 21:54:20 +0100199 "com.android.launcher.toolbar_voice_search_icon";
Patrick Dubroyceae05d2010-08-30 10:40:53 -0700200
Adam Cohen39a06042013-07-19 14:30:12 -0700201 public static final String SHOW_WEIGHT_WATCHER = "debug.show_mem";
Daniel Sandler6053b802013-08-15 15:44:26 -0700202 public static final boolean SHOW_WEIGHT_WATCHER_DEFAULT = false;
Adam Cohen39a06042013-07-19 14:30:12 -0700203
Winson Chunga6945242014-01-08 14:04:34 -0800204 public static final String USER_HAS_MIGRATED = "launcher.user_migrated_from_old_data";
205
Patrick Dubroy6b509c12010-08-23 15:08:16 -0700206 /** The different states that Launcher can be in. */
Winson Chung4a2afa32012-07-19 14:53:05 -0700207 private enum State { NONE, WORKSPACE, APPS_CUSTOMIZE, APPS_CUSTOMIZE_SPRING_LOADED };
Michael Jurkac0e8fca2010-10-06 16:41:29 -0700208 private State mState = State.WORKSPACE;
209 private AnimatorSet mStateAnimation;
Patrick Dubroy6b509c12010-08-23 15:08:16 -0700210
Joe Onorato9c1289c2009-08-17 11:03:03 -0400211 static final int APPWIDGET_HOST_ID = 1024;
Adam Cohenad4e15c2013-10-17 16:21:35 -0700212 public static final int EXIT_SPRINGLOADED_MODE_SHORT_TIMEOUT = 300;
213 private static final int ON_ACTIVITY_RESULT_ANIMATION_DELAY = 500;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800214
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800215 private static final Object sLock = new Object();
Mike Cleron3a2b3f22009-11-05 17:17:42 -0800216 private static int sScreen = DEFAULT_SCREEN;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800217
Adam Cohenc76e1dd2013-11-14 11:09:14 +0000218 private HashMap<Integer, Integer> mItemIdToViewId = new HashMap<Integer, Integer>();
219 private static final AtomicInteger sNextGeneratedId = new AtomicInteger(1);
220
Winson Chunga2413752012-04-03 14:22:34 -0700221 // How long to wait before the new-shortcut animation automatically pans the workspace
Winson Chung94d67682013-09-25 16:29:40 -0700222 private static int NEW_APPS_PAGE_MOVE_DELAY = 500;
223 private static int NEW_APPS_ANIMATION_INACTIVE_TIMEOUT_SECONDS = 5;
Winson Chung64359a52013-07-08 17:17:08 -0700224 private static int NEW_APPS_ANIMATION_DELAY = 500;
Winson Chunga2413752012-04-03 14:22:34 -0700225
Joe Onorato2ca0ae72009-11-10 13:14:13 -0800226 private final BroadcastReceiver mCloseSystemDialogsReceiver
227 = new CloseSystemDialogsIntentReceiver();
Jeff Sharkey1e2efc82009-11-06 15:17:59 -0800228 private final ContentObserver mWidgetObserver = new AppWidgetResetObserver();
229
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800230 private LayoutInflater mInflater;
231
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800232 private Workspace mWorkspace;
Craig Mautner360310b2012-10-26 15:13:08 -0700233 private View mLauncherView;
Winson Chunga6945242014-01-08 14:04:34 -0800234 private View mPageIndicators;
Michael Jurkab737ee62011-11-15 15:57:22 -0800235 private DragLayer mDragLayer;
236 private DragController mDragController;
Adam Cohen39a06042013-07-19 14:30:12 -0700237 private View mWeightWatcher;
Winson Chunga6945242014-01-08 14:04:34 -0800238 private LauncherClings mLauncherClings;
Romain Guycbb89e42009-06-08 15:52:54 -0700239
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700240 private AppWidgetManager mAppWidgetManager;
241 private LauncherAppWidgetHost mAppWidgetHost;
Romain Guycbb89e42009-06-08 15:52:54 -0700242
Michael Jurkac9d95c52011-08-29 14:03:34 -0700243 private ItemInfo mPendingAddInfo = new ItemInfo();
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700244 private AppWidgetProviderInfo mPendingAddWidgetInfo;
Adam Cohen4637b5a2013-11-04 18:21:24 -0800245 private int mPendingAddWidgetId = -1;
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700246
Michael Jurka0280c3b2010-09-17 15:00:07 -0700247 private int[] mTmpAddItemCellCoordinates = new int[2];
248
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800249 private FolderInfo mFolderInfo;
250
Winson Chung3d503fb2011-07-13 17:25:49 -0700251 private Hotseat mHotseat;
Jorim Jaggid017f882014-01-14 17:08:48 -0800252 private ViewGroup mOverviewPanel;
Adam Cohenf358a4b2013-07-23 16:47:31 -0700253
Michael Jurka838a4ca2011-02-07 13:33:06 -0800254 private View mAllAppsButton;
Winson Chung3d503fb2011-07-13 17:25:49 -0700255
Winson Chungc51db6a2011-10-05 11:44:49 -0700256 private SearchDropTargetBar mSearchDropTargetBar;
Winson Chungf0ea4d32011-06-06 14:27:16 -0700257 private AppsCustomizeTabHost mAppsCustomizeTabHost;
258 private AppsCustomizePagedView mAppsCustomizeContent;
259 private boolean mAutoAdvanceRunning = false;
Adam Cohen24ce0b32014-01-14 16:18:14 -0800260 private View mQsb;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800261
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800262 private Bundle mSavedState;
Winson Chung4a2afa32012-07-19 14:53:05 -0700263 // We set the state in both onCreate and then onNewIntent in some cases, which causes both
264 // scroll issues (because the workspace may not have been measured yet) and extra work.
265 // Instead, just save the state that we need to restore Launcher to, and commit it in onResume.
266 private State mOnResumeState = State.NONE;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800267
268 private SpannableStringBuilder mDefaultKeySsb = null;
269
Joe Onorato9c1289c2009-08-17 11:03:03 -0400270 private boolean mWorkspaceLoading = true;
271
Joe Onorato34a0e1b2009-12-14 17:44:51 -0800272 private boolean mPaused = true;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800273 private boolean mRestoring;
274 private boolean mWaitingForResult;
Joe Onoratoef2efcf2010-10-27 13:21:00 -0700275 private boolean mOnResumeNeedsLoad;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800276
Michael Jurka1e2f4652013-07-08 18:03:46 -0700277 private ArrayList<Runnable> mBindOnResumeCallbacks = new ArrayList<Runnable>();
Michael Jurka7607c2f2013-04-03 14:33:19 -0700278 private ArrayList<Runnable> mOnResumeCallbacks = new ArrayList<Runnable>();
279
Winson Chung4a2afa32012-07-19 14:53:05 -0700280 // Keep track of whether the user has left launcher
281 private static boolean sPausedFromUserAction = false;
282
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800283 private Bundle mSavedInstanceState;
284
Joe Onorato9c1289c2009-08-17 11:03:03 -0400285 private LauncherModel mModel;
Joe Onorato0589f0f2010-02-08 13:44:00 -0800286 private IconCache mIconCache;
Adam Cohend113e0c2010-11-11 10:48:05 -0800287 private boolean mUserPresent = true;
288 private boolean mVisible = false;
Adam Cohened307df2013-10-02 09:37:31 -0700289 private boolean mHasFocus = false;
Adam Cohend113e0c2010-11-11 10:48:05 -0800290 private boolean mAttached = false;
Joe Onorato9c1289c2009-08-17 11:03:03 -0400291
Brad Fitzpatrick319226a2010-09-01 13:45:16 -0700292 private static LocaleConfiguration sLocaleConfiguration = null;
293
Brad Fitzpatrick319226a2010-09-01 13:45:16 -0700294 private static HashMap<Long, FolderInfo> sFolders = new HashMap<Long, FolderInfo>();
Romain Guycbb89e42009-06-08 15:52:54 -0700295
Adam Cohen61f560d2013-09-30 15:58:20 -0700296 private View.OnTouchListener mHapticFeedbackTouchListener;
297
Adam Cohended9f8d2010-11-03 13:25:16 -0700298 // Related to the auto-advancing of widgets
299 private final int ADVANCE_MSG = 1;
300 private final int mAdvanceInterval = 20000;
301 private final int mAdvanceStagger = 250;
302 private long mAutoAdvanceSentTime;
303 private long mAutoAdvanceTimeLeft = -1;
304 private HashMap<View, AppWidgetProviderInfo> mWidgetsToAdvance =
305 new HashMap<View, AppWidgetProviderInfo>();
306
Winson Chung400438b2011-01-16 17:53:48 -0800307 // Determines how long to wait after a rotation before restoring the screen orientation to
308 // match the sensor state.
309 private final int mRestoreScreenOrientationDelay = 500;
310
Michael Jurka4ef207b2010-11-29 17:05:45 -0800311 // External icons saved in case of resource changes, orientation, etc.
Winson Chungdff8ebb2011-09-08 17:25:31 -0700312 private static Drawable.ConstantState[] sGlobalSearchIcon = new Drawable.ConstantState[2];
313 private static Drawable.ConstantState[] sVoiceSearchIcon = new Drawable.ConstantState[2];
314 private static Drawable.ConstantState[] sAppMarketIcon = new Drawable.ConstantState[2];
Michael Jurka4ef207b2010-11-29 17:05:45 -0800315
Winson Chungd64a6662013-09-30 11:06:59 -0700316 private Intent mAppMarketIntent = null;
317 private static final boolean DISABLE_MARKET_BUTTON = true;
318
Craig Mautner360310b2012-10-26 15:13:08 -0700319 private Drawable mWorkspaceBackgroundDrawable;
Craig Mautner360310b2012-10-26 15:13:08 -0700320
Adam Cohen1462de32012-07-24 22:34:36 -0700321 private final ArrayList<Integer> mSynchronouslyBoundPages = new ArrayList<Integer>();
Winson Chung6e1c0d32013-10-25 15:24:24 -0700322 private static final boolean DISABLE_SYNCHRONOUS_BINDING_CURRENT_PAGE = false;
Adam Cohen1462de32012-07-24 22:34:36 -0700323
Adam Cohen16d7ffc2011-10-05 17:49:14 -0700324 static final ArrayList<String> sDumpLogs = new ArrayList<String>();
Adam Cohen4caf2982013-08-20 18:54:31 -0700325 static Date sDateStamp = new Date();
326 static DateFormat sDateFormat =
327 DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT);
328 static long sRunStart = System.currentTimeMillis();
329 static final String CORRUPTION_EMAIL_SENT_KEY = "corruptionEmailSent";
Adam Cohen16d7ffc2011-10-05 17:49:14 -0700330
Winson Chung46353de2012-02-16 14:05:10 -0800331 // We only want to get the SharedPreferences once since it does an FS stat each time we get
332 // it from the context.
333 private SharedPreferences mSharedPrefs;
334
Adam Cohene25af792013-06-06 23:08:25 -0700335 private static ArrayList<ComponentName> mIntentsOnWorkspaceFromUpgradePath = null;
336
Winson Chungf0c6ae02012-03-21 16:10:31 -0700337 // Holds the page that we need to animate to, and the icon views that we need to animate up
338 // when we scroll to that page on resume.
Adam Cohen268c4752012-06-06 17:47:33 -0700339 private ImageView mFolderIconImageView;
340 private Bitmap mFolderIconBitmap;
341 private Canvas mFolderIconCanvas;
342 private Rect mRectForFolderAnimation = new Rect();
Adam Cohen2801caf2011-05-13 20:57:39 -0700343
Michael Jurkaddd62e92011-02-16 17:49:14 -0800344 private BubbleTextView mWaitingForResume;
345
Michael Jurkac1f5d262011-09-30 19:32:27 -0700346 private Runnable mBuildLayersRunnable = new Runnable() {
347 public void run() {
Michael Jurka9d906c72011-10-14 06:25:36 -0700348 if (mWorkspace != null) {
349 mWorkspace.buildPageHardwareLayers();
350 }
Michael Jurkac1f5d262011-09-30 19:32:27 -0700351 }
352 };
353
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800354 private static ArrayList<PendingAddArguments> sPendingAddList
355 = new ArrayList<PendingAddArguments>();
356
Michael Jurka7267fa52013-09-26 15:29:57 -0700357 public static boolean sForceEnableRotation = isPropertyEnabled(FORCE_ENABLE_ROTATION_PROPERTY);
Michael Jurka0a457bf2012-11-19 14:05:05 -0800358
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800359 private static class PendingAddArguments {
360 int requestCode;
361 Intent intent;
Winson Chung3d503fb2011-07-13 17:25:49 -0700362 long container;
Adam Cohendcd297f2013-06-18 13:13:40 -0700363 long screenId;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800364 int cellX;
365 int cellY;
366 }
367
Daniel Sandlerff02d492013-08-05 02:12:05 -0400368 private Stats mStats;
369
Nilesh Agrawal16f3ea82014-01-09 17:14:01 -0800370 static boolean isPropertyEnabled(String propertyName) {
Michael Jurka0a457bf2012-11-19 14:05:05 -0800371 return Log.isLoggable(propertyName, Log.VERBOSE);
Michael Jurka9bc8eba2012-05-21 20:36:44 -0700372 }
373
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800374 @Override
375 protected void onCreate(Bundle savedInstanceState) {
Winson Chunga2413752012-04-03 14:22:34 -0700376 if (DEBUG_STRICT_MODE) {
377 StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
378 .detectDiskReads()
379 .detectDiskWrites()
380 .detectNetwork() // or .detectAll() for all detectable problems
381 .penaltyLog()
382 .build());
383 StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
384 .detectLeakedSqlLiteObjects()
385 .detectLeakedClosableObjects()
386 .penaltyLog()
387 .penaltyDeath()
388 .build());
389 }
390
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800391 super.onCreate(savedInstanceState);
Daniel Sandlere060b0b2013-06-27 21:47:55 -0400392
Daniel Sandlere060b0b2013-06-27 21:47:55 -0400393 LauncherAppState.setApplicationContext(getApplicationContext());
Daniel Sandlercc8befa2013-06-11 14:45:48 -0400394 LauncherAppState app = LauncherAppState.getInstance();
Winson Chung5f8afe62013-08-12 16:19:28 -0700395
396 // Determine the dynamic grid properties
397 Point smallestSize = new Point();
398 Point largestSize = new Point();
399 Point realSize = new Point();
400 Display display = getWindowManager().getDefaultDisplay();
401 display.getCurrentSizeRange(smallestSize, largestSize);
402 display.getRealSize(realSize);
Winson Chung892c74d2013-08-22 16:15:50 -0700403 DisplayMetrics dm = new DisplayMetrics();
404 display.getMetrics(dm);
Winson Chung6e1c0d32013-10-25 15:24:24 -0700405
Winson Chung5f8afe62013-08-12 16:19:28 -0700406 // Lazy-initialize the dynamic grid
407 DeviceProfile grid = app.initDynamicGrid(this,
408 Math.min(smallestSize.x, smallestSize.y),
409 Math.min(largestSize.x, largestSize.y),
Winson Chung892c74d2013-08-22 16:15:50 -0700410 realSize.x, realSize.y,
411 dm.widthPixels, dm.heightPixels);
Winson Chung5f8afe62013-08-12 16:19:28 -0700412
413 // the LauncherApplication should call this, but in case of Instrumentation it might not be present yet
Daniel Sandlercc8befa2013-06-11 14:45:48 -0400414 mSharedPrefs = getSharedPreferences(LauncherAppState.getSharedPreferencesKey(),
Winson Chungf0c6ae02012-03-21 16:10:31 -0700415 Context.MODE_PRIVATE);
Joe Onorato0589f0f2010-02-08 13:44:00 -0800416 mModel = app.setLauncher(this);
417 mIconCache = app.getIconCache();
Winson Chunge5467dc2013-10-14 17:03:04 -0700418 mIconCache.flushInvalidIcons(grid);
Joe Onorato41a12d22009-10-31 18:30:00 -0400419 mDragController = new DragController(this);
Winson Chunga6945242014-01-08 14:04:34 -0800420 mLauncherClings = new LauncherClings(this);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800421 mInflater = getLayoutInflater();
Romain Guycbb89e42009-06-08 15:52:54 -0700422
Daniel Sandlerff02d492013-08-05 02:12:05 -0400423 mStats = new Stats(this);
424
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700425 mAppWidgetManager = AppWidgetManager.getInstance(this);
Adam Cohen53805212013-10-01 10:39:23 -0700426
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700427 mAppWidgetHost = new LauncherAppWidgetHost(this, APPWIDGET_HOST_ID);
428 mAppWidgetHost.startListening();
Romain Guycbb89e42009-06-08 15:52:54 -0700429
Winson Chungb8b2a5a2012-07-12 17:55:31 -0700430 // If we are getting an onCreate, we can actually preempt onResume and unset mPaused here,
431 // this also ensures that any synchronous binding below doesn't re-trigger another
432 // LauncherModel load.
433 mPaused = false;
434
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800435 if (PROFILE_STARTUP) {
Christian Mehlmauer0fbe7bc2010-08-02 20:27:46 +0200436 android.os.Debug.startMethodTracing(
437 Environment.getExternalStorageDirectory() + "/launcher");
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800438 }
439
Adam Cohen53805212013-10-01 10:39:23 -0700440
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800441 checkForLocaleChange();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800442 setContentView(R.layout.launcher);
Michael Jurka7267fa52013-09-26 15:29:57 -0700443
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800444 setupViews();
Cristina Stancu476493b2013-08-07 17:20:14 +0100445 grid.layout(this);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800446
Jeff Sharkey1e2efc82009-11-06 15:17:59 -0800447 registerContentObservers();
448
Joe Onorato7c312c12009-08-13 21:36:53 -0700449 lockAllApps();
Joe Onorato7404ee42009-07-31 11:54:44 -0700450
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800451 mSavedState = savedInstanceState;
452 restoreState(mSavedState);
453
454 if (PROFILE_STARTUP) {
455 android.os.Debug.stopMethodTracing();
456 }
457
458 if (!mRestoring) {
Winson Chung6e1c0d32013-10-25 15:24:24 -0700459 if (DISABLE_SYNCHRONOUS_BINDING_CURRENT_PAGE || sPausedFromUserAction) {
Winson Chung4a2afa32012-07-19 14:53:05 -0700460 // If the user leaves launcher, then we should just load items asynchronously when
461 // they return.
Derek Prothro7aff3992013-12-10 14:00:37 -0500462 mModel.startLoader(true, PagedView.INVALID_RESTORE_PAGE);
Winson Chung4a2afa32012-07-19 14:53:05 -0700463 } else {
464 // We only load the page synchronously if the user rotates (or triggers a
465 // configuration change) while launcher is in the foreground
Winson Chung9b9fb962013-11-15 15:39:34 -0800466 mModel.startLoader(true, mWorkspace.getRestorePage());
Winson Chung4a2afa32012-07-19 14:53:05 -0700467 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800468 }
469
470 // For handling default keys
471 mDefaultKeySsb = new SpannableStringBuilder();
472 Selection.setSelection(mDefaultKeySsb, 0);
Joe Onorato34a0e1b2009-12-14 17:44:51 -0800473
474 IntentFilter filter = new IntentFilter(Intent.ACTION_CLOSE_SYSTEM_DIALOGS);
475 registerReceiver(mCloseSystemDialogsReceiver, filter);
Michael Jurka4ef207b2010-11-29 17:05:45 -0800476
Adam Cohenf9426d52012-06-04 17:26:21 -0700477 updateGlobalIcons();
478
479 // On large interfaces, we want the screen to auto-rotate based on the current orientation
480 unlockScreenOrientation(true);
Winson Chungaf40f202013-09-18 18:26:31 -0700481
Winson Chunge43a1e72014-01-15 10:33:02 -0800482 // The two first run cling paths are mutually exclusive, if the launcher is preinstalled
483 // on the device, then we always show the first run cling experience (or if there is no
484 // launcher2). Otherwise, we prompt the user upon started for migration
Adam Cohenb54a5982014-01-08 15:21:04 -0800485 showFirstRunActivity();
Winson Chunge43a1e72014-01-15 10:33:02 -0800486 if (mLauncherClings.shouldShowFirstRunOrMigrationClings()) {
487 if (mModel.canMigrateFromOldLauncherDb(this)) {
488 mLauncherClings.showMigrationCling();
489 } else {
490 mLauncherClings.showFirstRunCling();
491 }
Winson Chunga6945242014-01-08 14:04:34 -0800492 } else {
Winson Chunge43a1e72014-01-15 10:33:02 -0800493 mLauncherClings.removeFirstRunAndMigrationClings();
Winson Chunga6945242014-01-08 14:04:34 -0800494 }
Adam Cohenf9426d52012-06-04 17:26:21 -0700495 }
496
Winson Chung4a2afa32012-07-19 14:53:05 -0700497 protected void onUserLeaveHint() {
498 super.onUserLeaveHint();
499 sPausedFromUserAction = true;
500 }
501
Winson Chung98ca0f72013-07-29 12:58:51 -0700502 /** To be overriden by subclasses to hint to Launcher that we have custom content */
503 protected boolean hasCustomContentToLeft() {
504 return false;
505 }
506
Dave Hawkeya8881582013-09-17 15:55:33 -0600507 /**
Derek Prothrodadd9842014-01-17 13:43:50 -0500508 * To be overridden by subclasses to populate the custom content container and call
Dave Hawkeya8881582013-09-17 15:55:33 -0600509 * {@link #addToCustomContentPage}. This will only be invoked if
510 * {@link #hasCustomContentToLeft()} is {@code true}.
511 */
Derek Prothrodadd9842014-01-17 13:43:50 -0500512 protected void populateCustomContentContainer() {
Dave Hawkeya8881582013-09-17 15:55:33 -0600513 }
514
515 /**
Adam Cohenb54a5982014-01-08 15:21:04 -0800516 * To be overridden by subclasses to indicate that there is an activity to launch
517 * before showing the standard launcher experience.
518 */
519 protected boolean hasFirstRunActivity() {
520 return false;
521 }
522
523 /**
524 * To be overridden by subclasses to launch any first run activity
525 */
526 protected Intent getFirstRunActivity() {
527 return null;
528 }
529
530 /**
Dave Hawkeya8881582013-09-17 15:55:33 -0600531 * Invoked by subclasses to signal a change to the {@link #addCustomContentToLeft} value to
532 * ensure the custom content page is added or removed if necessary.
533 */
534 protected void invalidateHasCustomContentToLeft() {
Dave Hawkey3a733a72013-09-30 11:52:21 -0600535 if (mWorkspace == null || mWorkspace.getScreenOrder().isEmpty()) {
Dave Hawkeya8881582013-09-17 15:55:33 -0600536 // Not bound yet, wait for bindScreens to be called.
537 return;
538 }
539
540 if (!mWorkspace.hasCustomContent() && hasCustomContentToLeft()) {
541 // Create the custom content page and call the subclass to populate it.
Derek Prothrodadd9842014-01-17 13:43:50 -0500542 mWorkspace.createCustomContentContainer();
543 populateCustomContentContainer();
Dave Hawkeya8881582013-09-17 15:55:33 -0600544 } else if (mWorkspace.hasCustomContent() && !hasCustomContentToLeft()) {
545 mWorkspace.removeCustomContentPage();
546 }
547 }
548
Adam Cohenf9426d52012-06-04 17:26:21 -0700549 private void updateGlobalIcons() {
Winson Chungc51db6a2011-10-05 11:44:49 -0700550 boolean searchVisible = false;
551 boolean voiceVisible = false;
Michael Jurka4ef207b2010-11-29 17:05:45 -0800552 // If we have a saved version of these external icons, we load them up immediately
Winson Chungdff8ebb2011-09-08 17:25:31 -0700553 int coi = getCurrentOrientationIndexForGlobalIcons();
554 if (sGlobalSearchIcon[coi] == null || sVoiceSearchIcon[coi] == null ||
555 sAppMarketIcon[coi] == null) {
Winson Chungd64a6662013-09-30 11:06:59 -0700556 if (!DISABLE_MARKET_BUTTON) {
557 updateAppMarketIcon();
558 }
Winson Chungc51db6a2011-10-05 11:44:49 -0700559 searchVisible = updateGlobalSearchIcon();
560 voiceVisible = updateVoiceSearchIcon(searchVisible);
Winson Chungf0ea4d32011-06-06 14:27:16 -0700561 }
Winson Chungdff8ebb2011-09-08 17:25:31 -0700562 if (sGlobalSearchIcon[coi] != null) {
563 updateGlobalSearchIcon(sGlobalSearchIcon[coi]);
Winson Chungc51db6a2011-10-05 11:44:49 -0700564 searchVisible = true;
Winson Chungf0ea4d32011-06-06 14:27:16 -0700565 }
Winson Chungdff8ebb2011-09-08 17:25:31 -0700566 if (sVoiceSearchIcon[coi] != null) {
567 updateVoiceSearchIcon(sVoiceSearchIcon[coi]);
Winson Chungc51db6a2011-10-05 11:44:49 -0700568 voiceVisible = true;
Winson Chungf0ea4d32011-06-06 14:27:16 -0700569 }
Winson Chungd64a6662013-09-30 11:06:59 -0700570 if (!DISABLE_MARKET_BUTTON && sAppMarketIcon[coi] != null) {
Winson Chungdff8ebb2011-09-08 17:25:31 -0700571 updateAppMarketIcon(sAppMarketIcon[coi]);
Michael Jurka4ef207b2010-11-29 17:05:45 -0800572 }
Winson Chungadf0c182012-08-23 14:59:07 -0700573 if (mSearchDropTargetBar != null) {
574 mSearchDropTargetBar.onSearchPackagesChanged(searchVisible, voiceVisible);
575 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800576 }
Romain Guycbb89e42009-06-08 15:52:54 -0700577
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800578 private void checkForLocaleChange() {
Brad Fitzpatrick319226a2010-09-01 13:45:16 -0700579 if (sLocaleConfiguration == null) {
580 new AsyncTask<Void, Void, LocaleConfiguration>() {
581 @Override
582 protected LocaleConfiguration doInBackground(Void... unused) {
583 LocaleConfiguration localeConfiguration = new LocaleConfiguration();
584 readConfiguration(Launcher.this, localeConfiguration);
585 return localeConfiguration;
586 }
587
588 @Override
589 protected void onPostExecute(LocaleConfiguration result) {
590 sLocaleConfiguration = result;
591 checkForLocaleChange(); // recursive, but now with a locale configuration
592 }
593 }.execute();
594 return;
595 }
Jason Samsfd22dac2009-09-20 17:24:16 -0700596
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800597 final Configuration configuration = getResources().getConfiguration();
598
Brad Fitzpatrick319226a2010-09-01 13:45:16 -0700599 final String previousLocale = sLocaleConfiguration.locale;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800600 final String locale = configuration.locale.toString();
601
Brad Fitzpatrick319226a2010-09-01 13:45:16 -0700602 final int previousMcc = sLocaleConfiguration.mcc;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800603 final int mcc = configuration.mcc;
604
Brad Fitzpatrick319226a2010-09-01 13:45:16 -0700605 final int previousMnc = sLocaleConfiguration.mnc;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800606 final int mnc = configuration.mnc;
607
Romain Guy84f296c2009-11-04 15:00:44 -0800608 boolean localeChanged = !locale.equals(previousLocale) || mcc != previousMcc || mnc != previousMnc;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800609
Romain Guy84f296c2009-11-04 15:00:44 -0800610 if (localeChanged) {
Brad Fitzpatrick319226a2010-09-01 13:45:16 -0700611 sLocaleConfiguration.locale = locale;
612 sLocaleConfiguration.mcc = mcc;
613 sLocaleConfiguration.mnc = mnc;
Romain Guy98d01652009-06-30 16:21:04 -0700614
Joe Onorato0589f0f2010-02-08 13:44:00 -0800615 mIconCache.flush();
Brad Fitzpatrick319226a2010-09-01 13:45:16 -0700616
617 final LocaleConfiguration localeConfiguration = sLocaleConfiguration;
Michael Jurka43467462013-11-14 12:03:58 +0100618 new AsyncTask<Void, Void, Void>() {
619 public Void doInBackground(Void ... args) {
Brad Fitzpatrick319226a2010-09-01 13:45:16 -0700620 writeConfiguration(Launcher.this, localeConfiguration);
Michael Jurka43467462013-11-14 12:03:58 +0100621 return null;
Brad Fitzpatrick319226a2010-09-01 13:45:16 -0700622 }
Michael Jurka43467462013-11-14 12:03:58 +0100623 }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, (Void) null);
Romain Guy98d01652009-06-30 16:21:04 -0700624 }
625 }
626
627 private static class LocaleConfiguration {
628 public String locale;
629 public int mcc = -1;
630 public int mnc = -1;
631 }
Jason Samsfd22dac2009-09-20 17:24:16 -0700632
Romain Guy98d01652009-06-30 16:21:04 -0700633 private static void readConfiguration(Context context, LocaleConfiguration configuration) {
634 DataInputStream in = null;
635 try {
636 in = new DataInputStream(context.openFileInput(PREFERENCES));
637 configuration.locale = in.readUTF();
638 configuration.mcc = in.readInt();
639 configuration.mnc = in.readInt();
640 } catch (FileNotFoundException e) {
641 // Ignore
642 } catch (IOException e) {
643 // Ignore
644 } finally {
645 if (in != null) {
646 try {
647 in.close();
648 } catch (IOException e) {
649 // Ignore
650 }
651 }
652 }
653 }
654
655 private static void writeConfiguration(Context context, LocaleConfiguration configuration) {
656 DataOutputStream out = null;
657 try {
658 out = new DataOutputStream(context.openFileOutput(PREFERENCES, MODE_PRIVATE));
659 out.writeUTF(configuration.locale);
660 out.writeInt(configuration.mcc);
661 out.writeInt(configuration.mnc);
662 out.flush();
663 } catch (FileNotFoundException e) {
664 // Ignore
665 } catch (IOException e) {
666 //noinspection ResultOfMethodCallIgnored
667 context.getFileStreamPath(PREFERENCES).delete();
668 } finally {
669 if (out != null) {
670 try {
671 out.close();
672 } catch (IOException e) {
673 // Ignore
674 }
675 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800676 }
677 }
678
Anton Hanssona2f665f2013-09-26 12:18:32 +0100679 public Stats getStats() {
680 return mStats;
681 }
682
Bjorn Bringertc459e522013-06-07 19:36:01 +0100683 public LayoutInflater getInflater() {
684 return mInflater;
685 }
686
Winson Chung36a62fe2012-05-06 18:04:42 -0700687 boolean isDraggingEnabled() {
688 // We prevent dragging when we are loading the workspace as it is possible to pick up a view
689 // that is subsequently removed from the workspace in startBinding().
690 return !mModel.isLoadingWorkspace();
691 }
692
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800693 static int getScreen() {
694 synchronized (sLock) {
695 return sScreen;
696 }
697 }
698
699 static void setScreen(int screen) {
700 synchronized (sLock) {
701 sScreen = screen;
702 }
703 }
704
Winson Chung557d6ed2011-07-08 15:34:52 -0700705 /**
Adam Cohenc76e1dd2013-11-14 11:09:14 +0000706 * Copied from View -- the View version of the method isn't called
707 * anywhere else in our process and only exists for API level 17+,
708 * so it's ok to keep our own version with no API requirement.
709 */
710 public static int generateViewId() {
711 for (;;) {
712 final int result = sNextGeneratedId.get();
713 // aapt-generated IDs have the high byte nonzero; clamp to the range under that.
714 int newValue = result + 1;
715 if (newValue > 0x00FFFFFF) newValue = 1; // Roll over to 1, not 0.
716 if (sNextGeneratedId.compareAndSet(result, newValue)) {
717 return result;
718 }
719 }
720 }
721
722 public int getViewIdForItem(ItemInfo info) {
723 // This cast is safe given the > 2B range for int.
724 int itemId = (int) info.id;
725 if (mItemIdToViewId.containsKey(itemId)) {
726 return mItemIdToViewId.get(itemId);
727 }
728 int viewId = generateViewId();
729 mItemIdToViewId.put(itemId, viewId);
730 return viewId;
731 }
732
733 /**
Winson Chung557d6ed2011-07-08 15:34:52 -0700734 * Returns whether we should delay spring loaded mode -- for shortcuts and widgets that have
735 * a configuration step, this allows the proper animations to run after other transitions.
736 */
737 private boolean completeAdd(PendingAddArguments args) {
Winson Chungb8472bb2011-08-05 13:49:21 -0700738 boolean result = false;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800739 switch (args.requestCode) {
740 case REQUEST_PICK_APPLICATION:
Adam Cohendcd297f2013-06-18 13:13:40 -0700741 completeAddApplication(args.intent, args.container, args.screenId, args.cellX,
Winson Chung3d503fb2011-07-13 17:25:49 -0700742 args.cellY);
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800743 break;
744 case REQUEST_PICK_SHORTCUT:
745 processShortcut(args.intent);
746 break;
747 case REQUEST_CREATE_SHORTCUT:
Adam Cohendcd297f2013-06-18 13:13:40 -0700748 completeAddShortcut(args.intent, args.container, args.screenId, args.cellX,
Winson Chung3d503fb2011-07-13 17:25:49 -0700749 args.cellY);
Winson Chungb8472bb2011-08-05 13:49:21 -0700750 result = true;
751 break;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800752 case REQUEST_CREATE_APPWIDGET:
753 int appWidgetId = args.intent.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1);
Adam Cohendcd297f2013-06-18 13:13:40 -0700754 completeAddAppWidget(appWidgetId, args.container, args.screenId, null, null);
Winson Chungb8472bb2011-08-05 13:49:21 -0700755 result = true;
756 break;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800757 }
Michael Jurka27614d22012-04-02 06:40:22 -0700758 // Before adding this resetAddInfo(), after a shortcut was added to a workspace screen,
759 // if you turned the screen off and then back while in All Apps, Launcher would not
760 // return to the workspace. Clearing mAddInfo.container here fixes this issue
761 resetAddInfo();
Winson Chungb8472bb2011-08-05 13:49:21 -0700762 return result;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800763 }
764
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800765 @Override
Michael Jurka8b805b12012-04-18 14:23:14 -0700766 protected void onActivityResult(
767 final int requestCode, final int resultCode, final Intent data) {
Winson Chunge341d302013-08-16 14:31:00 -0700768 // Reset the startActivity waiting flag
769 mWaitingForResult = false;
Adam Cohen4637b5a2013-11-04 18:21:24 -0800770 int pendingAddWidgetId = mPendingAddWidgetId;
771 mPendingAddWidgetId = -1;
Winson Chunge341d302013-08-16 14:31:00 -0700772
Adam Cohenad4e15c2013-10-17 16:21:35 -0700773 Runnable exitSpringLoaded = new Runnable() {
774 @Override
775 public void run() {
776 exitSpringLoadedDragModeDelayed((resultCode != RESULT_CANCELED),
777 EXIT_SPRINGLOADED_MODE_SHORT_TIMEOUT, null);
778 }
779 };
780
Michael Jurka8b805b12012-04-18 14:23:14 -0700781 if (requestCode == REQUEST_BIND_APPWIDGET) {
Adam Cohenad4e15c2013-10-17 16:21:35 -0700782 final int appWidgetId = data != null ?
Michael Jurka8b805b12012-04-18 14:23:14 -0700783 data.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1) : -1;
784 if (resultCode == RESULT_CANCELED) {
785 completeTwoStageWidgetDrop(RESULT_CANCELED, appWidgetId);
Adam Cohenad4e15c2013-10-17 16:21:35 -0700786 mWorkspace.removeExtraEmptyScreen(true, exitSpringLoaded,
787 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false);
Michael Jurka8b805b12012-04-18 14:23:14 -0700788 } else if (resultCode == RESULT_OK) {
Adam Cohenad4e15c2013-10-17 16:21:35 -0700789 addAppWidgetImpl(appWidgetId, mPendingAddInfo, null,
790 mPendingAddWidgetInfo, ON_ACTIVITY_RESULT_ANIMATION_DELAY);
Michael Jurka8b805b12012-04-18 14:23:14 -0700791 }
792 return;
Michael Jurka336fd4f2013-09-12 00:05:02 +0200793 } else if (requestCode == REQUEST_PICK_WALLPAPER) {
794 if (resultCode == RESULT_OK && mWorkspace.isInOverviewMode()) {
795 mWorkspace.exitOverviewMode(false);
796 }
797 return;
Michael Jurka8b805b12012-04-18 14:23:14 -0700798 }
Michael Jurka336fd4f2013-09-12 00:05:02 +0200799
Adam Cohened66b2b2012-01-23 17:28:51 -0800800 boolean isWidgetDrop = (requestCode == REQUEST_PICK_APPWIDGET ||
801 requestCode == REQUEST_CREATE_APPWIDGET);
Romain Guyaad5ef42009-06-10 02:48:37 -0700802
Adam Cohened66b2b2012-01-23 17:28:51 -0800803 // We have special handling for widgets
804 if (isWidgetDrop) {
Adam Cohen4637b5a2013-11-04 18:21:24 -0800805 final int appWidgetId;
806 int widgetId = data != null ? data.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1)
807 : -1;
808 if (widgetId < 0) {
809 appWidgetId = pendingAddWidgetId;
810 } else {
811 appWidgetId = widgetId;
812 }
813
Adam Cohenad4e15c2013-10-17 16:21:35 -0700814 final int result;
815 final Runnable onComplete;
Adam Cohenf0129b12013-11-04 17:57:36 -0800816 if (appWidgetId < 0 || resultCode == RESULT_CANCELED) {
Winson Chung5aaab772012-04-27 15:24:02 -0700817 Log.e(TAG, "Error: appWidgetId (EXTRA_APPWIDGET_ID) was not returned from the \\" +
818 "widget configuration activity.");
Adam Cohenad4e15c2013-10-17 16:21:35 -0700819 result = RESULT_CANCELED;
820 completeTwoStageWidgetDrop(result, appWidgetId);
821 onComplete = new Runnable() {
822 @Override
823 public void run() {
824 exitSpringLoadedDragModeDelayed(false, 0, null);
825 }
826 };
Winson Chung5aaab772012-04-27 15:24:02 -0700827 } else {
Adam Cohenad4e15c2013-10-17 16:21:35 -0700828 result = resultCode;
Adam Cohen917e3882013-10-31 15:03:35 -0700829 final CellLayout dropLayout =
830 (CellLayout) mWorkspace.getScreenWithId(mPendingAddInfo.screenId);
831 dropLayout.setDropPending(true);
Adam Cohenad4e15c2013-10-17 16:21:35 -0700832 onComplete = new Runnable() {
833 @Override
834 public void run() {
835 completeTwoStageWidgetDrop(result, appWidgetId);
Adam Cohen917e3882013-10-31 15:03:35 -0700836 dropLayout.setDropPending(false);
Adam Cohenad4e15c2013-10-17 16:21:35 -0700837 }
838 };
Winson Chung5aaab772012-04-27 15:24:02 -0700839 }
Adam Cohenad4e15c2013-10-17 16:21:35 -0700840 mWorkspace.removeExtraEmptyScreen(true, onComplete, ON_ACTIVITY_RESULT_ANIMATION_DELAY,
841 false);
Adam Cohened66b2b2012-01-23 17:28:51 -0800842 return;
843 }
844
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800845 // The pattern used here is that a user PICKs a specific application,
846 // which, depending on the target, might need to CREATE the actual target.
Romain Guycbb89e42009-06-08 15:52:54 -0700847
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800848 // For example, the user would PICK_SHORTCUT for "Music playlist", and we
849 // launch over to the Music app to actually CREATE_SHORTCUT.
Winson Chungc7da5552011-08-10 15:28:45 -0700850 if (resultCode == RESULT_OK && mPendingAddInfo.container != ItemInfo.NO_ID) {
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800851 final PendingAddArguments args = new PendingAddArguments();
852 args.requestCode = requestCode;
853 args.intent = data;
Winson Chung3d503fb2011-07-13 17:25:49 -0700854 args.container = mPendingAddInfo.container;
Adam Cohendcd297f2013-06-18 13:13:40 -0700855 args.screenId = mPendingAddInfo.screenId;
Winson Chung3d503fb2011-07-13 17:25:49 -0700856 args.cellX = mPendingAddInfo.cellX;
857 args.cellY = mPendingAddInfo.cellY;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800858 if (isWorkspaceLocked()) {
859 sPendingAddList.add(args);
860 } else {
Adam Cohenad4e15c2013-10-17 16:21:35 -0700861 completeAdd(args);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800862 }
Adam Cohenad4e15c2013-10-17 16:21:35 -0700863 mWorkspace.removeExtraEmptyScreen(true, exitSpringLoaded,
864 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false);
Adam Cohen00074722013-10-11 17:46:09 -0700865 } else if (resultCode == RESULT_CANCELED) {
Adam Cohenad4e15c2013-10-17 16:21:35 -0700866 mWorkspace.removeExtraEmptyScreen(true, exitSpringLoaded,
867 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800868 }
Adam Cohened66b2b2012-01-23 17:28:51 -0800869 mDragLayer.clearAnimatedView();
Adam Cohened66b2b2012-01-23 17:28:51 -0800870 }
871
872 private void completeTwoStageWidgetDrop(final int resultCode, final int appWidgetId) {
Michael Jurka8b805b12012-04-18 14:23:14 -0700873 CellLayout cellLayout =
Adam Cohendcd297f2013-06-18 13:13:40 -0700874 (CellLayout) mWorkspace.getScreenWithId(mPendingAddInfo.screenId);
Adam Cohened66b2b2012-01-23 17:28:51 -0800875 Runnable onCompleteRunnable = null;
876 int animationType = 0;
877
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700878 AppWidgetHostView boundWidget = null;
Adam Cohened66b2b2012-01-23 17:28:51 -0800879 if (resultCode == RESULT_OK) {
880 animationType = Workspace.COMPLETE_TWO_STAGE_WIDGET_DROP_ANIMATION;
881 final AppWidgetHostView layout = mAppWidgetHost.createView(this, appWidgetId,
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700882 mPendingAddWidgetInfo);
883 boundWidget = layout;
Adam Cohened66b2b2012-01-23 17:28:51 -0800884 onCompleteRunnable = new Runnable() {
885 @Override
886 public void run() {
887 completeAddAppWidget(appWidgetId, mPendingAddInfo.container,
Adam Cohendcd297f2013-06-18 13:13:40 -0700888 mPendingAddInfo.screenId, layout, null);
Adam Cohenad4e15c2013-10-17 16:21:35 -0700889 exitSpringLoadedDragModeDelayed((resultCode != RESULT_CANCELED),
890 EXIT_SPRINGLOADED_MODE_SHORT_TIMEOUT, null);
Adam Cohened66b2b2012-01-23 17:28:51 -0800891 }
892 };
893 } else if (resultCode == RESULT_CANCELED) {
Adam Cohen4637b5a2013-11-04 18:21:24 -0800894 mAppWidgetHost.deleteAppWidgetId(appWidgetId);
Adam Cohened66b2b2012-01-23 17:28:51 -0800895 animationType = Workspace.CANCEL_TWO_STAGE_WIDGET_DROP_ANIMATION;
Adam Cohened66b2b2012-01-23 17:28:51 -0800896 }
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700897 if (mDragLayer.getAnimatedView() != null) {
898 mWorkspace.animateWidgetDrop(mPendingAddInfo, cellLayout,
899 (DragView) mDragLayer.getAnimatedView(), onCompleteRunnable,
900 animationType, boundWidget, true);
Adam Cohenad4e15c2013-10-17 16:21:35 -0700901 } else if (onCompleteRunnable != null) {
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700902 // The animated view may be null in the case of a rotation during widget configuration
903 onCompleteRunnable.run();
904 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800905 }
906
907 @Override
Michael Jurkacd496d72013-04-11 11:32:45 -0700908 protected void onStop() {
909 super.onStop();
910 FirstFrameAnimatorHelper.setIsVisible(false);
911 }
912
913 @Override
914 protected void onStart() {
915 super.onStart();
916 FirstFrameAnimatorHelper.setIsVisible(true);
917 }
918
919 @Override
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800920 protected void onResume() {
Michael Jurka447bf842013-05-15 14:52:15 +0200921 long startTime = 0;
922 if (DEBUG_RESUME_TIME) {
923 startTime = System.currentTimeMillis();
Daniel Sandler924b9932013-06-12 00:38:25 -0400924 Log.v(TAG, "Launcher.onResume()");
Michael Jurka447bf842013-05-15 14:52:15 +0200925 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800926 super.onResume();
Winson Chungf0c6ae02012-03-21 16:10:31 -0700927
Winson Chung4a2afa32012-07-19 14:53:05 -0700928 // Restore the previous launcher state
929 if (mOnResumeState == State.WORKSPACE) {
930 showWorkspace(false);
931 } else if (mOnResumeState == State.APPS_CUSTOMIZE) {
Winson Chung07e045c2013-11-06 15:49:51 -0800932 showAllApps(false, mAppsCustomizeContent.getContentType(), false);
Winson Chung4a2afa32012-07-19 14:53:05 -0700933 }
934 mOnResumeState = State.NONE;
935
Craig Mautner360310b2012-10-26 15:13:08 -0700936 // Background was set to gradient in onPause(), restore to black if in all apps.
937 setWorkspaceBackground(mState == State.WORKSPACE);
938
Joe Onorato34a0e1b2009-12-14 17:44:51 -0800939 mPaused = false;
Winson Chung4a2afa32012-07-19 14:53:05 -0700940 sPausedFromUserAction = false;
Joe Onoratoef2efcf2010-10-27 13:21:00 -0700941 if (mRestoring || mOnResumeNeedsLoad) {
Joe Onorato9c1289c2009-08-17 11:03:03 -0400942 mWorkspaceLoading = true;
Derek Prothro7aff3992013-12-10 14:00:37 -0500943 mModel.startLoader(true, PagedView.INVALID_RESTORE_PAGE);
Joe Onorato9c1289c2009-08-17 11:03:03 -0400944 mRestoring = false;
Joe Onoratoef2efcf2010-10-27 13:21:00 -0700945 mOnResumeNeedsLoad = false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800946 }
Michael Jurka1e2f4652013-07-08 18:03:46 -0700947 if (mBindOnResumeCallbacks.size() > 0) {
Michael Jurkac402cd92013-05-20 15:49:32 +0200948 // We might have postponed some bind calls until onResume (see waitUntilResume) --
949 // execute them here
950 long startTimeCallbacks = 0;
951 if (DEBUG_RESUME_TIME) {
952 startTimeCallbacks = System.currentTimeMillis();
953 }
954
955 if (mAppsCustomizeContent != null) {
956 mAppsCustomizeContent.setBulkBind(true);
957 }
Michael Jurka1e2f4652013-07-08 18:03:46 -0700958 for (int i = 0; i < mBindOnResumeCallbacks.size(); i++) {
959 mBindOnResumeCallbacks.get(i).run();
Michael Jurkac402cd92013-05-20 15:49:32 +0200960 }
961 if (mAppsCustomizeContent != null) {
962 mAppsCustomizeContent.setBulkBind(false);
963 }
Michael Jurka1e2f4652013-07-08 18:03:46 -0700964 mBindOnResumeCallbacks.clear();
Michael Jurkac402cd92013-05-20 15:49:32 +0200965 if (DEBUG_RESUME_TIME) {
966 Log.d(TAG, "Time spent processing callbacks in onResume: " +
967 (System.currentTimeMillis() - startTimeCallbacks));
968 }
Michael Jurka447bf842013-05-15 14:52:15 +0200969 }
Michael Jurka54554252013-08-01 12:52:23 +0200970 if (mOnResumeCallbacks.size() > 0) {
971 for (int i = 0; i < mOnResumeCallbacks.size(); i++) {
972 mOnResumeCallbacks.get(i).run();
973 }
974 mOnResumeCallbacks.clear();
975 }
Winson Chunge4e50662012-01-23 14:45:13 -0800976
977 // Reset the pressed state of icons that were locked in the press state while activities
978 // were launching
Michael Jurkaddd62e92011-02-16 17:49:14 -0800979 if (mWaitingForResume != null) {
Winson Chunge4e50662012-01-23 14:45:13 -0800980 // Resets the previous workspace icon press state
Michael Jurkaddd62e92011-02-16 17:49:14 -0800981 mWaitingForResume.setStayPressed(false);
982 }
Winson Chunge4e50662012-01-23 14:45:13 -0800983 if (mAppsCustomizeContent != null) {
984 // Resets the previous all apps icon press state
985 mAppsCustomizeContent.resetDrawableState();
986 }
Winson Chung82963d52013-10-09 11:20:57 -0700987
Adam Cohen06dff352012-06-01 17:17:08 -0700988 // It is possible that widgets can receive updates while launcher is not in the foreground.
989 // Consequently, the widgets will be inflated in the orientation of the foreground activity
990 // (framework issue). On resuming, we ensure that any widgets are inflated for the current
991 // orientation.
Adam Cohen3d509322012-06-06 14:10:04 -0700992 getWorkspace().reinflateWidgetsIfNecessary();
Adam Cohenf9426d52012-06-04 17:26:21 -0700993
Winson Chung780fe592013-09-26 14:48:44 -0700994 // Process any items that were added while Launcher was away.
995 InstallShortcutReceiver.disableAndFlushInstallQueue(this);
996
Winson Chung5841efa2013-09-30 18:06:44 -0700997 // Update the voice search button proxy
998 updateVoiceButtonProxyVisible(false);
999
Adam Cohenf9426d52012-06-04 17:26:21 -07001000 // Again, as with the above scenario, it's possible that one or more of the global icons
1001 // were updated in the wrong orientation.
1002 updateGlobalIcons();
Michael Jurka447bf842013-05-15 14:52:15 +02001003 if (DEBUG_RESUME_TIME) {
1004 Log.d(TAG, "Time spent in onResume: " + (System.currentTimeMillis() - startTime));
1005 }
Adam Cohen6fecd412013-10-02 17:41:50 -07001006
1007 if (mWorkspace.getCustomContentCallbacks() != null) {
1008 // If we are resuming and the custom content is the current page, we call onShow().
1009 // It is also poassible that onShow will instead be called slightly after first layout
1010 // if PagedView#setRestorePage was set to the custom content page in onCreate().
1011 if (mWorkspace.isOnOrMovingToCustomContent()) {
1012 mWorkspace.getCustomContentCallbacks().onShow();
1013 }
1014 }
Adam Cohenedaaa302013-10-01 17:33:27 -07001015 mWorkspace.updateInteractionForState();
Adam Cohen53805212013-10-01 10:39:23 -07001016 mWorkspace.onResume();
Adam Cohen06dff352012-06-01 17:17:08 -07001017 }
1018
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001019 @Override
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001020 protected void onPause() {
Winson Chung997a9232013-07-24 15:33:46 -07001021 // Ensure that items added to Launcher are queued until Launcher returns
1022 InstallShortcutReceiver.enableInstallQueue();
1023
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001024 super.onPause();
Joe Onoratoef2efcf2010-10-27 13:21:00 -07001025 mPaused = true;
Joe Onorato24b6fd82009-11-12 13:47:09 -08001026 mDragController.cancelDrag();
Winson Chunga2413752012-04-03 14:22:34 -07001027 mDragController.resetLastGestureUpTime();
Adam Cohen6fecd412013-10-02 17:41:50 -07001028
1029 // We call onHide() aggressively. The custom content callbacks should be able to
1030 // debounce excess onHide calls.
1031 if (mWorkspace.getCustomContentCallbacks() != null) {
1032 mWorkspace.getCustomContentCallbacks().onHide();
1033 }
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001034 }
Romain Guycbb89e42009-06-08 15:52:54 -07001035
Adam Cohenbffe7452013-07-22 18:21:45 -07001036 QSBScroller mQsbScroller = new QSBScroller() {
1037 int scrollY = 0;
1038
1039 @Override
1040 public void setScrollY(int scroll) {
1041 scrollY = scroll;
1042
1043 if (mWorkspace.isOnOrMovingToCustomContent()) {
1044 mSearchDropTargetBar.setTranslationY(- scrollY);
Mark Brophyd7dc6812013-09-20 17:27:32 +01001045 getQsbBar().setTranslationY(-scrollY);
Adam Cohenbffe7452013-07-22 18:21:45 -07001046 }
1047 }
1048 };
1049
1050 public void resetQSBScroll() {
1051 mSearchDropTargetBar.animate().translationY(0).start();
Mark Brophyd7dc6812013-09-20 17:27:32 +01001052 getQsbBar().animate().translationY(0).start();
Adam Cohenbffe7452013-07-22 18:21:45 -07001053 }
1054
1055 public interface CustomContentCallbacks {
1056 // Custom content is completely shown
1057 public void onShow();
1058
1059 // Custom content is completely hidden
1060 public void onHide();
Adam Cohenc36fa5c2013-08-29 11:54:42 -07001061
1062 // Custom content scroll progress changed. From 0 (not showing) to 1 (fully showing).
1063 public void onScrollProgressChanged(float progress);
Adam Cohenbffe7452013-07-22 18:21:45 -07001064 }
1065
Jorim Jaggid017f882014-01-14 17:08:48 -08001066 protected boolean hasSettings() {
1067 return false;
1068 }
1069
Adam Cohen30bacb22013-08-29 14:25:25 -07001070 protected void startSettings() {
1071 }
1072
Adam Cohenbffe7452013-07-22 18:21:45 -07001073 public interface QSBScroller {
1074 public void setScrollY(int scrollY);
1075 }
1076
Winson Chung98ca0f72013-07-29 12:58:51 -07001077 public QSBScroller addToCustomContentPage(View customContent,
Adam Cohen53805212013-10-01 10:39:23 -07001078 CustomContentCallbacks callbacks, String description) {
1079 mWorkspace.addToCustomContentPage(customContent, callbacks, description);
Adam Cohenbffe7452013-07-22 18:21:45 -07001080 return mQsbScroller;
Adam Cohen66a01fd2013-06-11 12:48:00 -07001081 }
1082
Adam Cohenedb40762013-07-18 16:45:45 -07001083 // The custom content needs to offset its content to account for the QSB
1084 public int getTopOffsetForCustomContent() {
1085 return mWorkspace.getPaddingTop();
1086 }
1087
Jeffrey Sharkey99c87582009-03-24 17:59:43 -07001088 @Override
1089 public Object onRetainNonConfigurationInstance() {
Joe Onorato9c1289c2009-08-17 11:03:03 -04001090 // Flag the loader to stop early before switching
1091 mModel.stopLoader();
Winson Chung785d2eb2011-04-14 16:08:02 -07001092 if (mAppsCustomizeContent != null) {
1093 mAppsCustomizeContent.surrender();
1094 }
Romain Guy13c2e7b2010-03-10 19:45:00 -08001095 return Boolean.TRUE;
Jeffrey Sharkey99c87582009-03-24 17:59:43 -07001096 }
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001097
Joe Onorato2d7e7d02010-01-29 15:57:19 -08001098 // We can't hide the IME if it was forced open. So don't bother
Joe Onorato2d7e7d02010-01-29 15:57:19 -08001099 @Override
1100 public void onWindowFocusChanged(boolean hasFocus) {
1101 super.onWindowFocusChanged(hasFocus);
Adam Cohened307df2013-10-02 09:37:31 -07001102 mHasFocus = hasFocus;
Joe Onorato2d7e7d02010-01-29 15:57:19 -08001103 }
Joe Onorato2d7e7d02010-01-29 15:57:19 -08001104
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001105 private boolean acceptFilter() {
1106 final InputMethodManager inputManager = (InputMethodManager)
1107 getSystemService(Context.INPUT_METHOD_SERVICE);
1108 return !inputManager.isFullscreenMode();
1109 }
1110
1111 @Override
1112 public boolean onKeyDown(int keyCode, KeyEvent event) {
Winson Chung97d85d22011-04-13 11:27:36 -07001113 final int uniChar = event.getUnicodeChar();
1114 final boolean handled = super.onKeyDown(keyCode, event);
1115 final boolean isKeyNotWhitespace = uniChar > 0 && !Character.isWhitespace(uniChar);
1116 if (!handled && acceptFilter() && isKeyNotWhitespace) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001117 boolean gotKey = TextKeyListener.getInstance().onKeyDown(mWorkspace, mDefaultKeySsb,
1118 keyCode, event);
1119 if (gotKey && mDefaultKeySsb != null && mDefaultKeySsb.length() > 0) {
Karl Rosaen138a0412009-04-23 19:00:21 -07001120 // something usable has been typed - start a search
Romain Guycbb89e42009-06-08 15:52:54 -07001121 // the typed text will be retrieved and cleared by
Karl Rosaen138a0412009-04-23 19:00:21 -07001122 // showSearchDialog()
1123 // If there are multiple keystrokes before the search dialog takes focus,
1124 // onSearchRequested() will be called for every keystroke,
1125 // but it is idempotent, so it's fine.
1126 return onSearchRequested();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001127 }
1128 }
1129
Joe Onorato8a9625e2010-01-28 15:55:35 -08001130 // Eat the long press event so the keyboard doesn't come up.
1131 if (keyCode == KeyEvent.KEYCODE_MENU && event.isLongPress()) {
1132 return true;
1133 }
1134
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001135 return handled;
1136 }
1137
Karl Rosaen138a0412009-04-23 19:00:21 -07001138 private String getTypedText() {
1139 return mDefaultKeySsb.toString();
1140 }
1141
1142 private void clearTypedText() {
1143 mDefaultKeySsb.clear();
1144 mDefaultKeySsb.clearSpans();
1145 Selection.setSelection(mDefaultKeySsb, 0);
1146 }
1147
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001148 /**
Michael Jurka883f55b2010-10-21 15:47:14 -07001149 * Given the integer (ordinal) value of a State enum instance, convert it to a variable of type
1150 * State
1151 */
1152 private static State intToState(int stateOrdinal) {
1153 State state = State.WORKSPACE;
1154 final State[] stateValues = State.values();
1155 for (int i = 0; i < stateValues.length; i++) {
1156 if (stateValues[i].ordinal() == stateOrdinal) {
1157 state = stateValues[i];
1158 break;
1159 }
1160 }
1161 return state;
1162 }
1163
1164 /**
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001165 * Restores the previous state, if it exists.
1166 *
1167 * @param savedState The previous state.
1168 */
Adam Cohenc76e1dd2013-11-14 11:09:14 +00001169 @SuppressWarnings("unchecked")
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001170 private void restoreState(Bundle savedState) {
1171 if (savedState == null) {
1172 return;
1173 }
1174
Michael Jurka883f55b2010-10-21 15:47:14 -07001175 State state = intToState(savedState.getInt(RUNTIME_STATE, State.WORKSPACE.ordinal()));
Winson Chungf0ea4d32011-06-06 14:27:16 -07001176 if (state == State.APPS_CUSTOMIZE) {
Winson Chung4a2afa32012-07-19 14:53:05 -07001177 mOnResumeState = State.APPS_CUSTOMIZE;
Joe Onorato3a8820b2009-11-10 15:06:42 -08001178 }
1179
Adam Cohen21cd0022013-10-09 18:57:02 -07001180 int currentScreen = savedState.getInt(RUNTIME_STATE_CURRENT_SCREEN,
1181 PagedView.INVALID_RESTORE_PAGE);
1182 if (currentScreen != PagedView.INVALID_RESTORE_PAGE) {
Winson Chung8c87cd82013-07-23 16:20:10 -07001183 mWorkspace.setRestorePage(currentScreen);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001184 }
1185
Winson Chung3d503fb2011-07-13 17:25:49 -07001186 final long pendingAddContainer = savedState.getLong(RUNTIME_STATE_PENDING_ADD_CONTAINER, -1);
Adam Cohendcd297f2013-06-18 13:13:40 -07001187 final long pendingAddScreen = savedState.getLong(RUNTIME_STATE_PENDING_ADD_SCREEN, -1);
Michael Jurka0280c3b2010-09-17 15:00:07 -07001188
Winson Chung3d503fb2011-07-13 17:25:49 -07001189 if (pendingAddContainer != ItemInfo.NO_ID && pendingAddScreen > -1) {
1190 mPendingAddInfo.container = pendingAddContainer;
Adam Cohendcd297f2013-06-18 13:13:40 -07001191 mPendingAddInfo.screenId = pendingAddScreen;
Winson Chung3d503fb2011-07-13 17:25:49 -07001192 mPendingAddInfo.cellX = savedState.getInt(RUNTIME_STATE_PENDING_ADD_CELL_X);
1193 mPendingAddInfo.cellY = savedState.getInt(RUNTIME_STATE_PENDING_ADD_CELL_Y);
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001194 mPendingAddInfo.spanX = savedState.getInt(RUNTIME_STATE_PENDING_ADD_SPAN_X);
1195 mPendingAddInfo.spanY = savedState.getInt(RUNTIME_STATE_PENDING_ADD_SPAN_Y);
1196 mPendingAddWidgetInfo = savedState.getParcelable(RUNTIME_STATE_PENDING_ADD_WIDGET_INFO);
Adam Cohen4637b5a2013-11-04 18:21:24 -08001197 mPendingAddWidgetId = savedState.getInt(RUNTIME_STATE_PENDING_ADD_WIDGET_ID);
Adam Cohen87a9f5b2012-05-29 16:16:51 -07001198 mWaitingForResult = true;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001199 mRestoring = true;
1200 }
1201
1202 boolean renameFolder = savedState.getBoolean(RUNTIME_STATE_PENDING_FOLDER_RENAME, false);
1203 if (renameFolder) {
1204 long id = savedState.getLong(RUNTIME_STATE_PENDING_FOLDER_RENAME_ID);
Brad Fitzpatrick319226a2010-09-01 13:45:16 -07001205 mFolderInfo = mModel.getFolderById(this, sFolders, id);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001206 mRestoring = true;
1207 }
Winson Chunga12a2502010-12-20 14:41:35 -08001208
Winson Chung785d2eb2011-04-14 16:08:02 -07001209 // Restore the AppsCustomize tab
1210 if (mAppsCustomizeTabHost != null) {
1211 String curTab = savedState.getString("apps_customize_currentTab");
1212 if (curTab != null) {
Winson Chungc93e5ae2012-07-23 20:48:26 -07001213 mAppsCustomizeTabHost.setContentTypeImmediate(
Winson Chung785d2eb2011-04-14 16:08:02 -07001214 mAppsCustomizeTabHost.getContentTypeForTabTag(curTab));
Winson Chungf314b0e2011-08-16 11:54:27 -07001215 mAppsCustomizeContent.loadAssociatedPages(
1216 mAppsCustomizeContent.getCurrentPage());
Winson Chung785d2eb2011-04-14 16:08:02 -07001217 }
1218
Winson Chung5afbf7b2011-07-25 11:53:08 -07001219 int currentIndex = savedState.getInt("apps_customize_currentIndex");
1220 mAppsCustomizeContent.restorePageForIndex(currentIndex);
Winson Chung785d2eb2011-04-14 16:08:02 -07001221 }
Adam Cohenc76e1dd2013-11-14 11:09:14 +00001222 mItemIdToViewId = (HashMap<Integer, Integer>)
1223 savedState.getSerializable(RUNTIME_STATE_VIEW_IDS);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001224 }
1225
1226 /**
1227 * Finds all the views we need and configure them properly.
1228 */
1229 private void setupViews() {
Michael Jurkaa63c4522010-08-19 13:52:27 -07001230 final DragController dragController = mDragController;
Joe Onorato00acb122009-08-04 16:04:30 -04001231
Craig Mautner360310b2012-10-26 15:13:08 -07001232 mLauncherView = findViewById(R.id.launcher);
Winson Chung4c98d922011-05-31 16:50:48 -07001233 mDragLayer = (DragLayer) findViewById(R.id.drag_layer);
1234 mWorkspace = (Workspace) mDragLayer.findViewById(R.id.workspace);
Winson Chunga6945242014-01-08 14:04:34 -08001235 mPageIndicators = mDragLayer.findViewById(R.id.page_indicator);
Craig Mautner360310b2012-10-26 15:13:08 -07001236
John Spurlock77e1f472013-09-11 10:09:51 -04001237 mLauncherView.setSystemUiVisibility(
1238 View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION);
Craig Mautner360310b2012-10-26 15:13:08 -07001239 mWorkspaceBackgroundDrawable = getResources().getDrawable(R.drawable.workspace_bg);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001240
Winson Chung4c98d922011-05-31 16:50:48 -07001241 // Setup the drag layer
1242 mDragLayer.setup(this, dragController);
1243
Winson Chung3d503fb2011-07-13 17:25:49 -07001244 // Setup the hotseat
1245 mHotseat = (Hotseat) findViewById(R.id.hotseat);
1246 if (mHotseat != null) {
1247 mHotseat.setup(this);
Winson Chung11a1a532013-09-13 11:14:45 -07001248 mHotseat.setOnLongClickListener(this);
Winson Chung3d503fb2011-07-13 17:25:49 -07001249 }
1250
Jorim Jaggid017f882014-01-14 17:08:48 -08001251 mOverviewPanel = (ViewGroup) findViewById(R.id.overview_panel);
Adam Cohen61f560d2013-09-30 15:58:20 -07001252 View widgetButton = findViewById(R.id.widget_button);
1253 widgetButton.setOnClickListener(new OnClickListener() {
Adam Cohenf358a4b2013-07-23 16:47:31 -07001254 @Override
1255 public void onClick(View arg0) {
Winson Chung8e15fdf2013-11-11 15:47:45 -08001256 if (!mWorkspace.isSwitchingState()) {
1257 showAllApps(true, AppsCustomizePagedView.ContentType.Widgets, true);
1258 }
Adam Cohenf358a4b2013-07-23 16:47:31 -07001259 }
1260 });
Adam Cohen61f560d2013-09-30 15:58:20 -07001261 widgetButton.setOnTouchListener(getHapticFeedbackTouchListener());
1262
1263 View wallpaperButton = findViewById(R.id.wallpaper_button);
1264 wallpaperButton.setOnClickListener(new OnClickListener() {
Adam Cohenf358a4b2013-07-23 16:47:31 -07001265 @Override
1266 public void onClick(View arg0) {
Winson Chung8e15fdf2013-11-11 15:47:45 -08001267 if (!mWorkspace.isSwitchingState()) {
1268 startWallpaper();
1269 }
Adam Cohenf358a4b2013-07-23 16:47:31 -07001270 }
1271 });
Adam Cohen61f560d2013-09-30 15:58:20 -07001272 wallpaperButton.setOnTouchListener(getHapticFeedbackTouchListener());
1273
1274 View settingsButton = findViewById(R.id.settings_button);
Jorim Jaggid017f882014-01-14 17:08:48 -08001275 if (hasSettings()) {
1276 settingsButton.setOnClickListener(new OnClickListener() {
1277 @Override
1278 public void onClick(View arg0) {
1279 if (!mWorkspace.isSwitchingState()) {
1280 startSettings();
1281 }
1282 }
1283 });
1284 settingsButton.setOnTouchListener(getHapticFeedbackTouchListener());
1285 } else {
1286 settingsButton.setVisibility(View.GONE);
1287 FrameLayout.LayoutParams lp = (FrameLayout.LayoutParams) widgetButton.getLayoutParams();
1288 lp.gravity = Gravity.END | Gravity.TOP;
1289 widgetButton.requestLayout();
1290 }
1291
Adam Cohendbdff6b2013-09-18 19:09:15 -07001292 mOverviewPanel.setAlpha(0f);
Adam Cohenf358a4b2013-07-23 16:47:31 -07001293
Winson Chung4c98d922011-05-31 16:50:48 -07001294 // Setup the workspace
1295 mWorkspace.setHapticFeedbackEnabled(false);
1296 mWorkspace.setOnLongClickListener(this);
Adam Cohencff6af82011-09-13 14:51:53 -07001297 mWorkspace.setup(dragController);
Michael Jurkad74c9842011-07-10 12:44:21 -07001298 dragController.addDragListener(mWorkspace);
Winson Chung4c98d922011-05-31 16:50:48 -07001299
Winson Chungf0ea4d32011-06-06 14:27:16 -07001300 // Get the search/delete bar
Adam Cohen24ce0b32014-01-14 16:18:14 -08001301 mSearchDropTargetBar = (SearchDropTargetBar)
1302 mDragLayer.findViewById(R.id.search_drop_target_bar);
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07001303
Winson Chungf0ea4d32011-06-06 14:27:16 -07001304 // Setup AppsCustomize
Craig Mautner360310b2012-10-26 15:13:08 -07001305 mAppsCustomizeTabHost = (AppsCustomizeTabHost) findViewById(R.id.apps_customize_pane);
Winson Chungf0ea4d32011-06-06 14:27:16 -07001306 mAppsCustomizeContent = (AppsCustomizePagedView)
1307 mAppsCustomizeTabHost.findViewById(R.id.apps_customize_pane_content);
1308 mAppsCustomizeContent.setup(this, dragController);
Craig Mautner360310b2012-10-26 15:13:08 -07001309
Winson Chung3d503fb2011-07-13 17:25:49 -07001310 // Setup the drag controller (drop targets have to be added in reverse order in priority)
Winson Chung4c98d922011-05-31 16:50:48 -07001311 dragController.setDragScoller(mWorkspace);
1312 dragController.setScrollView(mDragLayer);
1313 dragController.setMoveTarget(mWorkspace);
1314 dragController.addDropTarget(mWorkspace);
Winson Chungc51db6a2011-10-05 11:44:49 -07001315 if (mSearchDropTargetBar != null) {
1316 mSearchDropTargetBar.setup(this, dragController);
Michael Jurkae0f5a612011-02-07 16:45:41 -08001317 }
Daniel Sandler924b9932013-06-12 00:38:25 -04001318
Daniel Sandlera127b7a2013-06-17 14:25:46 -04001319 if (getResources().getBoolean(R.bool.debug_memory_enabled)) {
Daniel Sandler924b9932013-06-12 00:38:25 -04001320 Log.v(TAG, "adding WeightWatcher");
Adam Cohen39a06042013-07-19 14:30:12 -07001321 mWeightWatcher = new WeightWatcher(this);
1322 mWeightWatcher.setAlpha(0.5f);
1323 ((FrameLayout) mLauncherView).addView(mWeightWatcher,
Daniel Sandler924b9932013-06-12 00:38:25 -04001324 new FrameLayout.LayoutParams(
1325 FrameLayout.LayoutParams.MATCH_PARENT,
Daniel Sandlerb9eb2862013-06-14 20:17:30 -04001326 FrameLayout.LayoutParams.WRAP_CONTENT,
Daniel Sandler924b9932013-06-12 00:38:25 -04001327 Gravity.BOTTOM)
1328 );
Adam Cohen39a06042013-07-19 14:30:12 -07001329
1330 boolean show = shouldShowWeightWatcher();
1331 mWeightWatcher.setVisibility(show ? View.VISIBLE : View.GONE);
Daniel Sandler924b9932013-06-12 00:38:25 -04001332 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001333 }
1334
1335 /**
1336 * Creates a view representing a shortcut.
1337 *
1338 * @param info The data structure describing the shortcut.
1339 *
1340 * @return A View inflated from R.layout.application.
1341 */
Joe Onorato0589f0f2010-02-08 13:44:00 -08001342 View createShortcut(ShortcutInfo info) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001343 return createShortcut(R.layout.application,
Michael Jurka0142d492010-08-25 17:46:15 -07001344 (ViewGroup) mWorkspace.getChildAt(mWorkspace.getCurrentPage()), info);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001345 }
1346
1347 /**
1348 * Creates a view representing a shortcut inflated from the specified resource.
1349 *
1350 * @param layoutResId The id of the XML layout used to create the shortcut.
1351 * @param parent The group the shortcut belongs to.
1352 * @param info The data structure describing the shortcut.
1353 *
1354 * @return A View inflated from layoutResId.
1355 */
Joe Onorato0589f0f2010-02-08 13:44:00 -08001356 View createShortcut(int layoutResId, ViewGroup parent, ShortcutInfo info) {
Michael Jurka67b2f6c2010-11-17 12:33:46 -08001357 BubbleTextView favorite = (BubbleTextView) mInflater.inflate(layoutResId, parent, false);
1358 favorite.applyFromShortcutInfo(info, mIconCache);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001359 favorite.setOnClickListener(this);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001360 return favorite;
1361 }
1362
1363 /**
1364 * Add an application shortcut to the workspace.
1365 *
1366 * @param data The intent describing the application.
1367 * @param cellInfo The position on screen where to create the shortcut.
1368 */
Adam Cohendcd297f2013-06-18 13:13:40 -07001369 void completeAddApplication(Intent data, long container, long screenId, int cellX, int cellY) {
Michael Jurka0280c3b2010-09-17 15:00:07 -07001370 final int[] cellXY = mTmpAddItemCellCoordinates;
Adam Cohendcd297f2013-06-18 13:13:40 -07001371 final CellLayout layout = getCellLayout(container, screenId);
Michael Jurka0280c3b2010-09-17 15:00:07 -07001372
Adam Cohenfbba09b2011-07-18 21:43:05 -07001373 // First we check if we already know the exact location where we want to add this item.
1374 if (cellX >= 0 && cellY >= 0) {
1375 cellXY[0] = cellX;
1376 cellXY[1] = cellY;
1377 } else if (!layout.findCellForSpan(cellXY, 1, 1)) {
Winson Chung93eef082012-03-23 15:59:27 -07001378 showOutOfSpaceMessage(isHotseatLayout(layout));
Michael Jurka0280c3b2010-09-17 15:00:07 -07001379 return;
1380 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001381
Patrick Dubroy002cbf42011-03-03 16:36:21 -08001382 final ShortcutInfo info = mModel.getShortcutInfo(getPackageManager(), data, this);
Joe Onorato0589f0f2010-02-08 13:44:00 -08001383
Romain Guy73b979d2009-06-09 12:57:21 -07001384 if (info != null) {
Michael Jurka1e2f4652013-07-08 18:03:46 -07001385 info.setActivity(this, data.getComponent(), Intent.FLAG_ACTIVITY_NEW_TASK |
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001386 Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
Joe Onorato0589f0f2010-02-08 13:44:00 -08001387 info.container = ItemInfo.NO_ID;
Adam Cohendcd297f2013-06-18 13:13:40 -07001388 mWorkspace.addApplicationShortcut(info, layout, container, screenId, cellXY[0], cellXY[1],
Adam Cohenfbba09b2011-07-18 21:43:05 -07001389 isWorkspaceLocked(), cellX, cellY);
Joe Onorato0589f0f2010-02-08 13:44:00 -08001390 } else {
1391 Log.e(TAG, "Couldn't find ActivityInfo for selected application: " + data);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001392 }
1393 }
Romain Guycbb89e42009-06-08 15:52:54 -07001394
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001395 /**
1396 * Add a shortcut to the workspace.
1397 *
1398 * @param data The intent describing the shortcut.
1399 * @param cellInfo The position on screen where to create the shortcut.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001400 */
Adam Cohendcd297f2013-06-18 13:13:40 -07001401 private void completeAddShortcut(Intent data, long container, long screenId, int cellX,
Winson Chung3d503fb2011-07-13 17:25:49 -07001402 int cellY) {
1403 int[] cellXY = mTmpAddItemCellCoordinates;
1404 int[] touchXY = mPendingAddInfo.dropPos;
Adam Cohendcd297f2013-06-18 13:13:40 -07001405 CellLayout layout = getCellLayout(container, screenId);
Romain Guycbb89e42009-06-08 15:52:54 -07001406
Michael Jurkad3ef3062010-11-23 16:23:58 -08001407 boolean foundCellSpan = false;
Adam Cohenfbba09b2011-07-18 21:43:05 -07001408
Adam Cohen558baaf2011-08-15 15:22:57 -07001409 ShortcutInfo info = mModel.infoFromShortcutIntent(this, data, null);
Adam Cohend9198822011-11-22 16:42:47 -08001410 if (info == null) {
1411 return;
1412 }
Adam Cohen558baaf2011-08-15 15:22:57 -07001413 final View view = createShortcut(info);
1414
Adam Cohenfbba09b2011-07-18 21:43:05 -07001415 // First we check if we already know the exact location where we want to add this item.
1416 if (cellX >= 0 && cellY >= 0) {
1417 cellXY[0] = cellX;
1418 cellXY[1] = cellY;
1419 foundCellSpan = true;
Adam Cohen558baaf2011-08-15 15:22:57 -07001420
1421 // If appropriate, either create a folder or add to an existing folder
Adam Cohen482ed822012-03-02 14:15:13 -08001422 if (mWorkspace.createUserFolderIfNecessary(view, container, layout, cellXY, 0,
Adam Cohen558baaf2011-08-15 15:22:57 -07001423 true, null,null)) {
1424 return;
1425 }
1426 DragObject dragObject = new DragObject();
1427 dragObject.dragInfo = info;
Adam Cohen482ed822012-03-02 14:15:13 -08001428 if (mWorkspace.addToExistingFolderIfNecessary(view, layout, cellXY, 0, dragObject,
1429 true)) {
Adam Cohen558baaf2011-08-15 15:22:57 -07001430 return;
1431 }
Adam Cohenfbba09b2011-07-18 21:43:05 -07001432 } else if (touchXY != null) {
Michael Jurkad3ef3062010-11-23 16:23:58 -08001433 // when dragging and dropping, just find the closest free spot
Winson Chung3d503fb2011-07-13 17:25:49 -07001434 int[] result = layout.findNearestVacantArea(touchXY[0], touchXY[1], 1, 1, cellXY);
Michael Jurkad3ef3062010-11-23 16:23:58 -08001435 foundCellSpan = (result != null);
1436 } else {
Adam Cohenfbba09b2011-07-18 21:43:05 -07001437 foundCellSpan = layout.findCellForSpan(cellXY, 1, 1);
Michael Jurkad3ef3062010-11-23 16:23:58 -08001438 }
1439
1440 if (!foundCellSpan) {
Winson Chung93eef082012-03-23 15:59:27 -07001441 showOutOfSpaceMessage(isHotseatLayout(layout));
Michael Jurka0280c3b2010-09-17 15:00:07 -07001442 return;
1443 }
1444
Adam Cohendcd297f2013-06-18 13:13:40 -07001445 LauncherModel.addItemToDatabase(this, info, container, screenId, cellXY[0], cellXY[1], false);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001446
1447 if (!mRestoring) {
Adam Cohendcd297f2013-06-18 13:13:40 -07001448 mWorkspace.addInScreen(view, container, screenId, cellXY[0], cellXY[1], 1, 1,
Winson Chung3d503fb2011-07-13 17:25:49 -07001449 isWorkspaceLocked());
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001450 }
1451 }
1452
Adam Cohen2f093b62012-04-30 18:59:53 -07001453 static int[] getSpanForWidget(Context context, ComponentName component, int minWidth,
1454 int minHeight) {
1455 Rect padding = AppWidgetHostView.getDefaultPaddingForWidget(context, component, null);
Adam Cohenf814aa02011-09-01 13:48:05 -07001456 // We want to account for the extra amount of padding that we are adding to the widget
1457 // to ensure that it gets the full amount of space that it has requested
1458 int requiredWidth = minWidth + padding.left + padding.right;
1459 int requiredHeight = minHeight + padding.top + padding.bottom;
Winson Chung66700732013-08-20 16:56:15 -07001460 return CellLayout.rectToCell(requiredWidth, requiredHeight, null);
Adam Cohenf814aa02011-09-01 13:48:05 -07001461 }
1462
Adam Cohen2f093b62012-04-30 18:59:53 -07001463 static int[] getSpanForWidget(Context context, AppWidgetProviderInfo info) {
1464 return getSpanForWidget(context, info.provider, info.minWidth, info.minHeight);
Adam Cohenf814aa02011-09-01 13:48:05 -07001465 }
1466
Adam Cohen2f093b62012-04-30 18:59:53 -07001467 static int[] getMinSpanForWidget(Context context, AppWidgetProviderInfo info) {
1468 return getSpanForWidget(context, info.provider, info.minResizeWidth, info.minResizeHeight);
Adam Cohencbf47e32011-09-16 17:32:37 -07001469 }
1470
Adam Cohen2f093b62012-04-30 18:59:53 -07001471 static int[] getSpanForWidget(Context context, PendingAddWidgetInfo info) {
1472 return getSpanForWidget(context, info.componentName, info.minWidth, info.minHeight);
Adam Cohenf814aa02011-09-01 13:48:05 -07001473 }
1474
Adam Cohen2f093b62012-04-30 18:59:53 -07001475 static int[] getMinSpanForWidget(Context context, PendingAddWidgetInfo info) {
1476 return getSpanForWidget(context, info.componentName, info.minResizeWidth,
Winson Chunga5c96362012-04-12 14:04:41 -07001477 info.minResizeHeight);
Adam Cohend41fbf52012-02-16 23:53:59 -08001478 }
1479
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001480 /**
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001481 * Add a widget to the workspace.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001482 *
Romain Guy5bbc91b2010-08-18 11:38:46 -07001483 * @param appWidgetId The app widget id
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001484 * @param cellInfo The position on screen where to create the widget.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001485 */
Adam Cohendcd297f2013-06-18 13:13:40 -07001486 private void completeAddAppWidget(final int appWidgetId, long container, long screenId,
Adam Cohened66b2b2012-01-23 17:28:51 -08001487 AppWidgetHostView hostView, AppWidgetProviderInfo appWidgetInfo) {
1488 if (appWidgetInfo == null) {
1489 appWidgetInfo = mAppWidgetManager.getAppWidgetInfo(appWidgetId);
1490 }
Romain Guycbb89e42009-06-08 15:52:54 -07001491
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001492 // Calculate the grid spans needed to fit this widget
Adam Cohendcd297f2013-06-18 13:13:40 -07001493 CellLayout layout = getCellLayout(container, screenId);
Adam Cohen09353862011-07-14 16:10:03 -07001494
Adam Cohen2f093b62012-04-30 18:59:53 -07001495 int[] minSpanXY = getMinSpanForWidget(this, appWidgetInfo);
1496 int[] spanXY = getSpanForWidget(this, appWidgetInfo);
Romain Guycbb89e42009-06-08 15:52:54 -07001497
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001498 // Try finding open space on Launcher screen
Michael Jurkaa63c4522010-08-19 13:52:27 -07001499 // We have saved the position to which the widget was dragged-- this really only matters
1500 // if we are placing widgets on a "spring-loaded" screen
Winson Chung3d503fb2011-07-13 17:25:49 -07001501 int[] cellXY = mTmpAddItemCellCoordinates;
1502 int[] touchXY = mPendingAddInfo.dropPos;
Adam Cohend41fbf52012-02-16 23:53:59 -08001503 int[] finalSpan = new int[2];
Michael Jurka0280c3b2010-09-17 15:00:07 -07001504 boolean foundCellSpan = false;
Winson Chung3d503fb2011-07-13 17:25:49 -07001505 if (mPendingAddInfo.cellX >= 0 && mPendingAddInfo.cellY >= 0) {
1506 cellXY[0] = mPendingAddInfo.cellX;
1507 cellXY[1] = mPendingAddInfo.cellY;
Adam Cohend41fbf52012-02-16 23:53:59 -08001508 spanXY[0] = mPendingAddInfo.spanX;
1509 spanXY[1] = mPendingAddInfo.spanY;
Adam Cohenfbba09b2011-07-18 21:43:05 -07001510 foundCellSpan = true;
1511 } else if (touchXY != null) {
Michael Jurka0280c3b2010-09-17 15:00:07 -07001512 // when dragging and dropping, just find the closest free spot
Winson Chung3d503fb2011-07-13 17:25:49 -07001513 int[] result = layout.findNearestVacantArea(
Adam Cohend41fbf52012-02-16 23:53:59 -08001514 touchXY[0], touchXY[1], minSpanXY[0], minSpanXY[1], spanXY[0],
1515 spanXY[1], cellXY, finalSpan);
1516 spanXY[0] = finalSpan[0];
1517 spanXY[1] = finalSpan[1];
Michael Jurkad3ef3062010-11-23 16:23:58 -08001518 foundCellSpan = (result != null);
Michael Jurka0280c3b2010-09-17 15:00:07 -07001519 } else {
Adam Cohend41fbf52012-02-16 23:53:59 -08001520 foundCellSpan = layout.findCellForSpan(cellXY, minSpanXY[0], minSpanXY[1]);
Michael Jurkaa63c4522010-08-19 13:52:27 -07001521 }
1522
Michael Jurka0280c3b2010-09-17 15:00:07 -07001523 if (!foundCellSpan) {
Winson Chungf7640c82011-02-28 13:47:29 -08001524 if (appWidgetId != -1) {
1525 // Deleting an app widget ID is a void call but writes to disk before returning
1526 // to the caller...
Michael Jurka43467462013-11-14 12:03:58 +01001527 new AsyncTask<Void, Void, Void>() {
1528 public Void doInBackground(Void ... args) {
Winson Chungf7640c82011-02-28 13:47:29 -08001529 mAppWidgetHost.deleteAppWidgetId(appWidgetId);
Michael Jurka43467462013-11-14 12:03:58 +01001530 return null;
Winson Chungf7640c82011-02-28 13:47:29 -08001531 }
Michael Jurka43467462013-11-14 12:03:58 +01001532 }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, (Void) null);
Winson Chungf7640c82011-02-28 13:47:29 -08001533 }
Winson Chung93eef082012-03-23 15:59:27 -07001534 showOutOfSpaceMessage(isHotseatLayout(layout));
Romain Guy18042c82009-11-06 11:44:55 -08001535 return;
1536 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001537
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001538 // Build Launcher-specific widget info and save to database
Winson Chung11a49372012-04-27 15:12:38 -07001539 LauncherAppWidgetInfo launcherInfo = new LauncherAppWidgetInfo(appWidgetId,
1540 appWidgetInfo.provider);
Michael Jurka0280c3b2010-09-17 15:00:07 -07001541 launcherInfo.spanX = spanXY[0];
1542 launcherInfo.spanY = spanXY[1];
Adam Cohend41fbf52012-02-16 23:53:59 -08001543 launcherInfo.minSpanX = mPendingAddInfo.minSpanX;
1544 launcherInfo.minSpanY = mPendingAddInfo.minSpanY;
Romain Guycbb89e42009-06-08 15:52:54 -07001545
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001546 LauncherModel.addItemToDatabase(this, launcherInfo,
Adam Cohendcd297f2013-06-18 13:13:40 -07001547 container, screenId, cellXY[0], cellXY[1], false);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001548
1549 if (!mRestoring) {
Adam Cohened66b2b2012-01-23 17:28:51 -08001550 if (hostView == null) {
1551 // Perform actual inflation because we're live
1552 launcherInfo.hostView = mAppWidgetHost.createView(this, appWidgetId, appWidgetInfo);
1553 launcherInfo.hostView.setAppWidget(appWidgetId, appWidgetInfo);
1554 } else {
1555 // The AppWidgetHostView has already been inflated and instantiated
1556 launcherInfo.hostView = hostView;
1557 }
Romain Guycbb89e42009-06-08 15:52:54 -07001558
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001559 launcherInfo.hostView.setTag(launcherInfo);
Adam Cohend41fbf52012-02-16 23:53:59 -08001560 launcherInfo.hostView.setVisibility(View.VISIBLE);
Adam Cohenaaa5c212012-10-05 18:14:31 -07001561 launcherInfo.notifyWidgetSizeChanged(this);
1562
Adam Cohendcd297f2013-06-18 13:13:40 -07001563 mWorkspace.addInScreen(launcherInfo.hostView, container, screenId, cellXY[0], cellXY[1],
Joe Onorato9c1289c2009-08-17 11:03:03 -04001564 launcherInfo.spanX, launcherInfo.spanY, isWorkspaceLocked());
Adam Cohended9f8d2010-11-03 13:25:16 -07001565
1566 addWidgetToAutoAdvanceIfNeeded(launcherInfo.hostView, appWidgetInfo);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001567 }
Adam Cohen6af9af02012-02-02 15:41:45 -08001568 resetAddInfo();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001569 }
Romain Guycbb89e42009-06-08 15:52:54 -07001570
Adam Cohended9f8d2010-11-03 13:25:16 -07001571 private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
1572 @Override
1573 public void onReceive(Context context, Intent intent) {
1574 final String action = intent.getAction();
1575 if (Intent.ACTION_SCREEN_OFF.equals(action)) {
1576 mUserPresent = false;
Adam Cohenbec6ac52011-07-19 20:50:27 -07001577 mDragLayer.clearAllResizeFrames();
Adam Cohended9f8d2010-11-03 13:25:16 -07001578 updateRunning();
Winson Chung337cd9d2011-03-30 10:39:30 -07001579
Winson Chungc100e8e2011-08-09 16:02:43 -07001580 // Reset AllApps to its initial state only if we are not in the middle of
Winson Chungb8472bb2011-08-05 13:49:21 -07001581 // processing a multi-step drop
Winson Chungc100e8e2011-08-09 16:02:43 -07001582 if (mAppsCustomizeTabHost != null && mPendingAddInfo.container == ItemInfo.NO_ID) {
Adam Cohened307df2013-10-02 09:37:31 -07001583 showWorkspace(false);
Winson Chung785d2eb2011-04-14 16:08:02 -07001584 }
Adam Cohended9f8d2010-11-03 13:25:16 -07001585 } else if (Intent.ACTION_USER_PRESENT.equals(action)) {
1586 mUserPresent = true;
1587 updateRunning();
Dan Sandlerd5024042014-01-09 15:01:33 -05001588 } else if (ENABLE_DEBUG_INTENTS && DebugIntents.DELETE_DATABASE.equals(action)) {
1589 mModel.resetLoadedState(false, true);
1590 mModel.startLoader(false, PagedView.INVALID_RESTORE_PAGE,
1591 LauncherModel.LOADER_FLAG_CLEAR_WORKSPACE);
1592 } else if (ENABLE_DEBUG_INTENTS && DebugIntents.MIGRATE_DATABASE.equals(action)) {
1593 mModel.resetLoadedState(false, true);
1594 mModel.startLoader(false, PagedView.INVALID_RESTORE_PAGE,
1595 LauncherModel.LOADER_FLAG_CLEAR_WORKSPACE
1596 | LauncherModel.LOADER_FLAG_MIGRATE_SHORTCUTS);
Adam Cohended9f8d2010-11-03 13:25:16 -07001597 }
1598 }
1599 };
1600
1601 @Override
1602 public void onAttachedToWindow() {
1603 super.onAttachedToWindow();
1604
1605 // Listen for broadcasts related to user-presence
1606 final IntentFilter filter = new IntentFilter();
1607 filter.addAction(Intent.ACTION_SCREEN_OFF);
1608 filter.addAction(Intent.ACTION_USER_PRESENT);
Dan Sandlerd5024042014-01-09 15:01:33 -05001609 if (ENABLE_DEBUG_INTENTS) {
1610 filter.addAction(DebugIntents.DELETE_DATABASE);
1611 filter.addAction(DebugIntents.MIGRATE_DATABASE);
1612 }
Adam Cohended9f8d2010-11-03 13:25:16 -07001613 registerReceiver(mReceiver, filter);
Michael Jurkaf1ad6082013-03-13 12:55:46 +01001614 FirstFrameAnimatorHelper.initializeDrawListener(getWindow().getDecorView());
Adam Cohend113e0c2010-11-11 10:48:05 -08001615 mAttached = true;
Adam Cohended9f8d2010-11-03 13:25:16 -07001616 mVisible = true;
1617 }
1618
1619 @Override
1620 public void onDetachedFromWindow() {
1621 super.onDetachedFromWindow();
1622 mVisible = false;
1623
Adam Cohend113e0c2010-11-11 10:48:05 -08001624 if (mAttached) {
1625 unregisterReceiver(mReceiver);
1626 mAttached = false;
1627 }
Adam Cohended9f8d2010-11-03 13:25:16 -07001628 updateRunning();
1629 }
1630
1631 public void onWindowVisibilityChanged(int visibility) {
1632 mVisible = visibility == View.VISIBLE;
1633 updateRunning();
Michael Jurka2a4b1a82011-12-07 14:00:02 -08001634 // The following code used to be in onResume, but it turns out onResume is called when
1635 // you're in All Apps and click home to go to the workspace. onWindowVisibilityChanged
1636 // is a more appropriate event to handle
1637 if (mVisible) {
1638 mAppsCustomizeTabHost.onWindowVisible();
1639 if (!mWorkspaceLoading) {
1640 final ViewTreeObserver observer = mWorkspace.getViewTreeObserver();
Michael Jurka2a4b1a82011-12-07 14:00:02 -08001641 // We want to let Launcher draw itself at least once before we force it to build
1642 // layers on all the workspace pages, so that transitioning to Launcher from other
Michael Jurkaf1ad6082013-03-13 12:55:46 +01001643 // apps is nice and speedy.
1644 observer.addOnDrawListener(new ViewTreeObserver.OnDrawListener() {
Michael Jurkadf96add2013-04-03 16:25:02 -07001645 private boolean mStarted = false;
Michael Jurkaf1ad6082013-03-13 12:55:46 +01001646 public void onDraw() {
Michael Jurkadf96add2013-04-03 16:25:02 -07001647 if (mStarted) return;
1648 mStarted = true;
Michael Jurka6ee21d22012-02-21 18:20:27 -08001649 // We delay the layer building a bit in order to give
1650 // other message processing a time to run. In particular
1651 // this avoids a delay in hiding the IME if it was
1652 // currently shown, because doing that may involve
1653 // some communication back with the app.
Winson Chungaeae56b2012-02-24 15:47:27 -08001654 mWorkspace.postDelayed(mBuildLayersRunnable, 500);
Michael Jurkadf96add2013-04-03 16:25:02 -07001655 final ViewTreeObserver.OnDrawListener listener = this;
1656 mWorkspace.post(new Runnable() {
1657 public void run() {
Michael Jurkab68e03a2013-04-11 11:36:41 -07001658 if (mWorkspace != null &&
1659 mWorkspace.getViewTreeObserver() != null) {
1660 mWorkspace.getViewTreeObserver().
1661 removeOnDrawListener(listener);
1662 }
Michael Jurkadf96add2013-04-03 16:25:02 -07001663 }
1664 });
Michael Jurkaf1ad6082013-03-13 12:55:46 +01001665 return;
Michael Jurka2a4b1a82011-12-07 14:00:02 -08001666 }
1667 });
1668 }
Michael Jurka6ee21d22012-02-21 18:20:27 -08001669 // When Launcher comes back to foreground, a different Activity might be responsible for
1670 // the app market intent, so refresh the icon
Winson Chungd64a6662013-09-30 11:06:59 -07001671 if (!DISABLE_MARKET_BUTTON) {
1672 updateAppMarketIcon();
1673 }
Michael Jurka2a4b1a82011-12-07 14:00:02 -08001674 clearTypedText();
1675 }
Adam Cohended9f8d2010-11-03 13:25:16 -07001676 }
1677
1678 private void sendAdvanceMessage(long delay) {
1679 mHandler.removeMessages(ADVANCE_MSG);
1680 Message msg = mHandler.obtainMessage(ADVANCE_MSG);
1681 mHandler.sendMessageDelayed(msg, delay);
1682 mAutoAdvanceSentTime = System.currentTimeMillis();
1683 }
1684
1685 private void updateRunning() {
1686 boolean autoAdvanceRunning = mVisible && mUserPresent && !mWidgetsToAdvance.isEmpty();
1687 if (autoAdvanceRunning != mAutoAdvanceRunning) {
1688 mAutoAdvanceRunning = autoAdvanceRunning;
1689 if (autoAdvanceRunning) {
1690 long delay = mAutoAdvanceTimeLeft == -1 ? mAdvanceInterval : mAutoAdvanceTimeLeft;
1691 sendAdvanceMessage(delay);
1692 } else {
1693 if (!mWidgetsToAdvance.isEmpty()) {
1694 mAutoAdvanceTimeLeft = Math.max(0, mAdvanceInterval -
1695 (System.currentTimeMillis() - mAutoAdvanceSentTime));
1696 }
1697 mHandler.removeMessages(ADVANCE_MSG);
Patrick Dubroy2313eff2011-01-11 20:01:31 -08001698 mHandler.removeMessages(0); // Remove messages sent using postDelayed()
Adam Cohended9f8d2010-11-03 13:25:16 -07001699 }
1700 }
1701 }
1702
1703 private final Handler mHandler = new Handler() {
1704 @Override
1705 public void handleMessage(Message msg) {
1706 if (msg.what == ADVANCE_MSG) {
1707 int i = 0;
1708 for (View key: mWidgetsToAdvance.keySet()) {
1709 final View v = key.findViewById(mWidgetsToAdvance.get(key).autoAdvanceViewId);
1710 final int delay = mAdvanceStagger * i;
1711 if (v instanceof Advanceable) {
1712 postDelayed(new Runnable() {
1713 public void run() {
1714 ((Advanceable) v).advance();
1715 }
1716 }, delay);
1717 }
1718 i++;
1719 }
1720 sendAdvanceMessage(mAdvanceInterval);
1721 }
1722 }
1723 };
1724
1725 void addWidgetToAutoAdvanceIfNeeded(View hostView, AppWidgetProviderInfo appWidgetInfo) {
Adam Cohen292c0252011-07-18 13:55:17 -07001726 if (appWidgetInfo == null || appWidgetInfo.autoAdvanceViewId == -1) return;
Adam Cohended9f8d2010-11-03 13:25:16 -07001727 View v = hostView.findViewById(appWidgetInfo.autoAdvanceViewId);
1728 if (v instanceof Advanceable) {
1729 mWidgetsToAdvance.put(hostView, appWidgetInfo);
Adam Cohen2ddf13e2011-01-19 21:26:33 -08001730 ((Advanceable) v).fyiWillBeAdvancedByHostKThx();
Adam Cohended9f8d2010-11-03 13:25:16 -07001731 updateRunning();
1732 }
1733 }
1734
1735 void removeWidgetToAutoAdvance(View hostView) {
1736 if (mWidgetsToAdvance.containsKey(hostView)) {
1737 mWidgetsToAdvance.remove(hostView);
1738 updateRunning();
1739 }
Michael Jurka0280c3b2010-09-17 15:00:07 -07001740 }
1741
Joe Onorato9c1289c2009-08-17 11:03:03 -04001742 public void removeAppWidget(LauncherAppWidgetInfo launcherInfo) {
Adam Cohended9f8d2010-11-03 13:25:16 -07001743 removeWidgetToAutoAdvance(launcherInfo.hostView);
Joe Onorato9c1289c2009-08-17 11:03:03 -04001744 launcherInfo.hostView = null;
1745 }
1746
Winson Chung93eef082012-03-23 15:59:27 -07001747 void showOutOfSpaceMessage(boolean isHotseatLayout) {
1748 int strId = (isHotseatLayout ? R.string.hotseat_out_of_space : R.string.out_of_space);
1749 Toast.makeText(this, getString(strId), Toast.LENGTH_SHORT).show();
Adam Cohended9f8d2010-11-03 13:25:16 -07001750 }
1751
Winson Chunga6945242014-01-08 14:04:34 -08001752 public DragLayer getDragLayer() {
1753 return mDragLayer;
1754 }
1755
1756 public Workspace getWorkspace() {
1757 return mWorkspace;
1758 }
1759
1760 public Hotseat getHotseat() {
1761 return mHotseat;
1762 }
1763
Jorim Jaggid017f882014-01-14 17:08:48 -08001764 public ViewGroup getOverviewPanel() {
Winson Chunga6945242014-01-08 14:04:34 -08001765 return mOverviewPanel;
1766 }
1767
1768 public SearchDropTargetBar getSearchBar() {
1769 return mSearchDropTargetBar;
1770 }
1771
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001772 public LauncherAppWidgetHost getAppWidgetHost() {
1773 return mAppWidgetHost;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001774 }
Romain Guycbb89e42009-06-08 15:52:54 -07001775
Winson Chunga9abd0e2010-10-27 17:18:37 -07001776 public LauncherModel getModel() {
1777 return mModel;
1778 }
1779
Winson Chunga6945242014-01-08 14:04:34 -08001780 public LauncherClings getLauncherClings() {
1781 return mLauncherClings;
1782 }
1783
1784 protected SharedPreferences getSharedPrefs() {
1785 return mSharedPrefs;
1786 }
1787
Bjorn Bringertc459e522013-06-07 19:36:01 +01001788 public void closeSystemDialogs() {
Joe Onorato2ca0ae72009-11-10 13:14:13 -08001789 getWindow().closeAllPanels();
1790
Joe Onoratoa5c32d62009-11-19 10:28:49 -08001791 // Whatever we were doing is hereby canceled.
1792 mWaitingForResult = false;
Joe Onorato2ca0ae72009-11-10 13:14:13 -08001793 }
1794
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001795 @Override
1796 protected void onNewIntent(Intent intent) {
Michael Jurka447bf842013-05-15 14:52:15 +02001797 long startTime = 0;
1798 if (DEBUG_RESUME_TIME) {
1799 startTime = System.currentTimeMillis();
1800 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001801 super.onNewIntent(intent);
1802
1803 // Close the menu
1804 if (Intent.ACTION_MAIN.equals(intent.getAction())) {
Joe Onoratoa5c32d62009-11-19 10:28:49 -08001805 // also will cancel mWaitingForResult.
Joe Onorato2ca0ae72009-11-10 13:14:13 -08001806 closeSystemDialogs();
Jason Samsfd22dac2009-09-20 17:24:16 -07001807
Adam Cohened307df2013-10-02 09:37:31 -07001808 final boolean alreadyOnHome = mHasFocus && ((intent.getFlags() &
1809 Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT)
1810 != Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT);
Michael Jurka01f0ed42010-08-20 00:41:17 -07001811
Adam Cohen6fecd412013-10-02 17:41:50 -07001812 if (mWorkspace == null) {
1813 // Can be cases where mWorkspace is null, this prevents a NPE
1814 return;
1815 }
1816 Folder openFolder = mWorkspace.getOpenFolder();
1817 // In all these cases, only animate if we're already on home
1818 mWorkspace.exitWidgetResizeMode();
1819 if (alreadyOnHome && mState == State.WORKSPACE && !mWorkspace.isTouchActive() &&
Adam Coppa120b8e2013-11-12 16:26:04 +00001820 openFolder == null && shouldMoveToDefaultScreenOnHomeIntent()) {
Adam Cohen6fecd412013-10-02 17:41:50 -07001821 mWorkspace.moveToDefaultScreen(true);
Winson Chung4a2afa32012-07-19 14:53:05 -07001822 }
Romain Guy1dd3a072009-07-16 13:21:01 -07001823
Adam Cohen6fecd412013-10-02 17:41:50 -07001824 closeFolder();
1825 exitSpringLoadedDragMode();
1826
1827 // If we are already on home, then just animate back to the workspace,
1828 // otherwise, just wait until onResume to set the state back to Workspace
1829 if (alreadyOnHome) {
Adam Cohened307df2013-10-02 09:37:31 -07001830 showWorkspace(true);
Adam Cohen6fecd412013-10-02 17:41:50 -07001831 } else {
1832 mOnResumeState = State.WORKSPACE;
1833 }
1834
1835 final View v = getWindow().peekDecorView();
1836 if (v != null && v.getWindowToken() != null) {
1837 InputMethodManager imm = (InputMethodManager)getSystemService(
1838 INPUT_METHOD_SERVICE);
1839 imm.hideSoftInputFromWindow(v.getWindowToken(), 0);
1840 }
1841
1842 // Reset the apps customize page
Winson Chunge7e97e62013-12-02 17:02:50 -08001843 if (!alreadyOnHome && mAppsCustomizeTabHost != null) {
Adam Cohen6fecd412013-10-02 17:41:50 -07001844 mAppsCustomizeTabHost.reset();
1845 }
Adam Coppa120b8e2013-11-12 16:26:04 +00001846
1847 onHomeIntent();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001848 }
Adam Cohened307df2013-10-02 09:37:31 -07001849
Michael Jurka447bf842013-05-15 14:52:15 +02001850 if (DEBUG_RESUME_TIME) {
1851 Log.d(TAG, "Time spent in onNewIntent: " + (System.currentTimeMillis() - startTime));
1852 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001853 }
1854
Adam Coppa120b8e2013-11-12 16:26:04 +00001855 /**
1856 * Override point for subclasses to prevent movement to the default screen when the home
1857 * button is pressed. Used (for example) in GEL, to prevent movement during a search.
1858 */
1859 protected boolean shouldMoveToDefaultScreenOnHomeIntent() {
1860 return true;
1861 }
1862
1863 /**
1864 * Override point for subclasses to provide custom behaviour for when a home intent is fired.
1865 */
1866 protected void onHomeIntent() {
1867 // Do nothing
1868 }
1869
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001870 @Override
Adam Cohen1462de32012-07-24 22:34:36 -07001871 public void onRestoreInstanceState(Bundle state) {
1872 super.onRestoreInstanceState(state);
1873 for (int page: mSynchronouslyBoundPages) {
1874 mWorkspace.restoreInstanceStateForChild(page);
1875 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001876 }
1877
1878 @Override
1879 protected void onSaveInstanceState(Bundle outState) {
Adam Cohen21cd0022013-10-09 18:57:02 -07001880 if (mWorkspace.getChildCount() > 0) {
Winson Chung9b9fb962013-11-15 15:39:34 -08001881 outState.putInt(RUNTIME_STATE_CURRENT_SCREEN,
1882 mWorkspace.getCurrentPageOffsetFromCustomContent());
Adam Cohen21cd0022013-10-09 18:57:02 -07001883 }
Adam Cohen95bb8002011-07-03 23:40:28 -07001884 super.onSaveInstanceState(outState);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001885
Michael Jurka883f55b2010-10-21 15:47:14 -07001886 outState.putInt(RUNTIME_STATE, mState.ordinal());
Adam Cohen51e95032011-07-11 14:44:19 -07001887 // We close any open folder since it will not be re-opened, and we need to make sure
1888 // this state is reflected.
1889 closeFolder();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001890
Adam Cohendcd297f2013-06-18 13:13:40 -07001891 if (mPendingAddInfo.container != ItemInfo.NO_ID && mPendingAddInfo.screenId > -1 &&
Winson Chung3d503fb2011-07-13 17:25:49 -07001892 mWaitingForResult) {
1893 outState.putLong(RUNTIME_STATE_PENDING_ADD_CONTAINER, mPendingAddInfo.container);
Adam Cohendcd297f2013-06-18 13:13:40 -07001894 outState.putLong(RUNTIME_STATE_PENDING_ADD_SCREEN, mPendingAddInfo.screenId);
Winson Chung3d503fb2011-07-13 17:25:49 -07001895 outState.putInt(RUNTIME_STATE_PENDING_ADD_CELL_X, mPendingAddInfo.cellX);
1896 outState.putInt(RUNTIME_STATE_PENDING_ADD_CELL_Y, mPendingAddInfo.cellY);
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001897 outState.putInt(RUNTIME_STATE_PENDING_ADD_SPAN_X, mPendingAddInfo.spanX);
1898 outState.putInt(RUNTIME_STATE_PENDING_ADD_SPAN_Y, mPendingAddInfo.spanY);
1899 outState.putParcelable(RUNTIME_STATE_PENDING_ADD_WIDGET_INFO, mPendingAddWidgetInfo);
Adam Cohen4637b5a2013-11-04 18:21:24 -08001900 outState.putInt(RUNTIME_STATE_PENDING_ADD_WIDGET_ID, mPendingAddWidgetId);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001901 }
1902
1903 if (mFolderInfo != null && mWaitingForResult) {
1904 outState.putBoolean(RUNTIME_STATE_PENDING_FOLDER_RENAME, true);
1905 outState.putLong(RUNTIME_STATE_PENDING_FOLDER_RENAME_ID, mFolderInfo.id);
1906 }
Michael Jurka946ad472010-07-09 18:05:18 -07001907
Winson Chung785d2eb2011-04-14 16:08:02 -07001908 // Save the current AppsCustomize tab
1909 if (mAppsCustomizeTabHost != null) {
Winson Chung07e045c2013-11-06 15:49:51 -08001910 AppsCustomizePagedView.ContentType type = mAppsCustomizeContent.getContentType();
1911 String currentTabTag = mAppsCustomizeTabHost.getTabTagForContentType(type);
Winson Chung785d2eb2011-04-14 16:08:02 -07001912 if (currentTabTag != null) {
1913 outState.putString("apps_customize_currentTab", currentTabTag);
1914 }
Winson Chung5afbf7b2011-07-25 11:53:08 -07001915 int currentIndex = mAppsCustomizeContent.getSaveInstanceStateIndex();
1916 outState.putInt("apps_customize_currentIndex", currentIndex);
Winson Chung785d2eb2011-04-14 16:08:02 -07001917 }
Adam Cohenc76e1dd2013-11-14 11:09:14 +00001918 outState.putSerializable(RUNTIME_STATE_VIEW_IDS, mItemIdToViewId);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001919 }
1920
1921 @Override
1922 public void onDestroy() {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001923 super.onDestroy();
Romain Guycbb89e42009-06-08 15:52:54 -07001924
Winson Chunge7a03942011-08-05 15:05:12 -07001925 // Remove all pending runnables
1926 mHandler.removeMessages(ADVANCE_MSG);
1927 mHandler.removeMessages(0);
Michael Jurka9d906c72011-10-14 06:25:36 -07001928 mWorkspace.removeCallbacks(mBuildLayersRunnable);
Winson Chunge7a03942011-08-05 15:05:12 -07001929
Winson Chungcd2b0142011-06-08 16:02:26 -07001930 // Stop callbacks from LauncherModel
Daniel Sandlercc8befa2013-06-11 14:45:48 -04001931 LauncherAppState app = (LauncherAppState.getInstance());
Winson Chungcd2b0142011-06-08 16:02:26 -07001932 mModel.stopLoader();
1933 app.setLauncher(null);
1934
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001935 try {
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001936 mAppWidgetHost.stopListening();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001937 } catch (NullPointerException ex) {
Joe Onoratoa30ce8e2009-11-11 08:16:49 -08001938 Log.w(TAG, "problem while stopping AppWidgetHost during Launcher destruction", ex);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001939 }
Patrick Dubroy2313eff2011-01-11 20:01:31 -08001940 mAppWidgetHost = null;
1941
1942 mWidgetsToAdvance.clear();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001943
1944 TextKeyListener.getInstance().release();
1945
Winson Chung81b52252012-08-27 15:34:29 -07001946 // Disconnect any of the callbacks and drawables associated with ItemInfos on the workspace
1947 // to prevent leaking Launcher activities on orientation change.
1948 if (mModel != null) {
1949 mModel.unbindItemInfosAndClearQueuedBindRunnables();
1950 }
Jeff Sharkey1e2efc82009-11-06 15:17:59 -08001951
1952 getContentResolver().unregisterContentObserver(mWidgetObserver);
Joe Onorato34a0e1b2009-12-14 17:44:51 -08001953 unregisterReceiver(mCloseSystemDialogsReceiver);
Patrick Dubroy2313eff2011-01-11 20:01:31 -08001954
Adam Cohenaccf3bf2012-04-30 16:07:43 -07001955 mDragLayer.clearAllResizeFrames();
Patrick Dubroy2313eff2011-01-11 20:01:31 -08001956 ((ViewGroup) mWorkspace.getParent()).removeAllViews();
Adam Cohend552dd92013-11-26 12:13:11 -08001957 mWorkspace.removeAllWorkspaceScreens();
Patrick Dubroy2313eff2011-01-11 20:01:31 -08001958 mWorkspace = null;
1959 mDragController = null;
Patrick Dubroy60b7c532011-01-16 17:19:32 -08001960
Michael Jurka2ecf9952012-06-18 12:52:28 -07001961 LauncherAnimUtils.onDestroyActivity();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001962 }
1963
Adam Cohena9cf38f2011-05-02 15:36:58 -07001964 public DragController getDragController() {
1965 return mDragController;
1966 }
1967
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001968 @Override
1969 public void startActivityForResult(Intent intent, int requestCode) {
Romain Guy08f97492009-06-29 14:41:20 -07001970 if (requestCode >= 0) mWaitingForResult = true;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001971 super.startActivityForResult(intent, requestCode);
1972 }
1973
Winson Chung70d72102011-08-12 11:24:35 -07001974 /**
1975 * Indicates that we want global search for this activity by setting the globalSearch
1976 * argument for {@link #startSearch} to true.
1977 */
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001978 @Override
Romain Guycbb89e42009-06-08 15:52:54 -07001979 public void startSearch(String initialQuery, boolean selectInitialQuery,
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001980 Bundle appSearchData, boolean globalSearch) {
Karl Rosaen138a0412009-04-23 19:00:21 -07001981
Michael Jurkac0e8fca2010-10-06 16:41:29 -07001982 showWorkspace(true);
Romain Guycbb89e42009-06-08 15:52:54 -07001983
Karl Rosaen138a0412009-04-23 19:00:21 -07001984 if (initialQuery == null) {
1985 // Use any text typed in the launcher as the initial query
1986 initialQuery = getTypedText();
Karl Rosaen138a0412009-04-23 19:00:21 -07001987 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001988 if (appSearchData == null) {
1989 appSearchData = new Bundle();
Bjorn Bringert32b12d22013-06-06 13:00:41 +01001990 appSearchData.putString("source", "launcher-search");
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001991 }
Winson Chungadf0c182012-08-23 14:59:07 -07001992 Rect sourceBounds = new Rect();
1993 if (mSearchDropTargetBar != null) {
1994 sourceBounds = mSearchDropTargetBar.getSearchBarBounds();
1995 }
Romain Guycbb89e42009-06-08 15:52:54 -07001996
Bjorn Bringertc459e522013-06-07 19:36:01 +01001997 startSearch(initialQuery, selectInitialQuery,
1998 appSearchData, sourceBounds);
1999 }
2000
2001 public void startSearch(String initialQuery,
2002 boolean selectInitialQuery, Bundle appSearchData, Rect sourceBounds) {
Michael Jurkaa33411c2012-06-14 16:18:21 -07002003 startGlobalSearch(initialQuery, selectInitialQuery,
Bjorn Bringertc459e522013-06-07 19:36:01 +01002004 appSearchData, sourceBounds);
Michael Jurkaa33411c2012-06-14 16:18:21 -07002005 }
2006
2007 /**
2008 * Starts the global search activity. This code is a copied from SearchManager
2009 */
Bjorn Bringertc459e522013-06-07 19:36:01 +01002010 private void startGlobalSearch(String initialQuery,
Michael Jurkaa33411c2012-06-14 16:18:21 -07002011 boolean selectInitialQuery, Bundle appSearchData, Rect sourceBounds) {
Karl Rosaen138a0412009-04-23 19:00:21 -07002012 final SearchManager searchManager =
Michael Jurkaa33411c2012-06-14 16:18:21 -07002013 (SearchManager) getSystemService(Context.SEARCH_SERVICE);
2014 ComponentName globalSearchActivity = searchManager.getGlobalSearchActivity();
2015 if (globalSearchActivity == null) {
2016 Log.w(TAG, "No global search activity found.");
2017 return;
2018 }
2019 Intent intent = new Intent(SearchManager.INTENT_ACTION_GLOBAL_SEARCH);
2020 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
2021 intent.setComponent(globalSearchActivity);
2022 // Make sure that we have a Bundle to put source in
2023 if (appSearchData == null) {
2024 appSearchData = new Bundle();
2025 } else {
2026 appSearchData = new Bundle(appSearchData);
2027 }
2028 // Set source to package name of app that starts global search, if not set already.
2029 if (!appSearchData.containsKey("source")) {
2030 appSearchData.putString("source", getPackageName());
2031 }
2032 intent.putExtra(SearchManager.APP_DATA, appSearchData);
2033 if (!TextUtils.isEmpty(initialQuery)) {
2034 intent.putExtra(SearchManager.QUERY, initialQuery);
2035 }
2036 if (selectInitialQuery) {
2037 intent.putExtra(SearchManager.EXTRA_SELECT_QUERY, selectInitialQuery);
2038 }
2039 intent.setSourceBounds(sourceBounds);
2040 try {
2041 startActivity(intent);
2042 } catch (ActivityNotFoundException ex) {
2043 Log.e(TAG, "Global search activity not found: " + globalSearchActivity);
2044 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002045 }
2046
Winson Chung70d72102011-08-12 11:24:35 -07002047 @Override
Winson Chung70d72102011-08-12 11:24:35 -07002048 public boolean onPrepareOptionsMenu(Menu menu) {
2049 super.onPrepareOptionsMenu(menu);
Winson Chunge0298742014-01-17 12:03:00 -08002050 // Close any open folders
2051 closeFolder();
2052 // Stop resizing any widgets
2053 mWorkspace.exitWidgetResizeMode();
2054 if (!mWorkspace.isInOverviewMode()) {
2055 // Show the overview mode
2056 showOverviewMode(true);
2057 } else {
2058 showWorkspace(true);
2059 }
Michael Jurkab94f3f82013-09-11 18:08:54 +02002060 return false;
Winson Chung70d72102011-08-12 11:24:35 -07002061 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002062
The Android Open Source Projectca9475f2009-03-13 13:04:24 -07002063 @Override
2064 public boolean onSearchRequested() {
Romain Guycbb89e42009-06-08 15:52:54 -07002065 startSearch(null, false, null, true);
Amith Yamasania135ba82011-08-09 17:42:01 -07002066 // Use a custom animation for launching search
Karl Rosaen138a0412009-04-23 19:00:21 -07002067 return true;
The Android Open Source Projectca9475f2009-03-13 13:04:24 -07002068 }
2069
Joe Onorato9c1289c2009-08-17 11:03:03 -04002070 public boolean isWorkspaceLocked() {
2071 return mWorkspaceLoading || mWaitingForResult;
2072 }
2073
Michael Jurka0280c3b2010-09-17 15:00:07 -07002074 private void resetAddInfo() {
Winson Chung3d503fb2011-07-13 17:25:49 -07002075 mPendingAddInfo.container = ItemInfo.NO_ID;
Adam Cohendcd297f2013-06-18 13:13:40 -07002076 mPendingAddInfo.screenId = -1;
Winson Chung3d503fb2011-07-13 17:25:49 -07002077 mPendingAddInfo.cellX = mPendingAddInfo.cellY = -1;
2078 mPendingAddInfo.spanX = mPendingAddInfo.spanY = -1;
Adam Cohend41fbf52012-02-16 23:53:59 -08002079 mPendingAddInfo.minSpanX = mPendingAddInfo.minSpanY = -1;
Winson Chung3d503fb2011-07-13 17:25:49 -07002080 mPendingAddInfo.dropPos = null;
Michael Jurka0280c3b2010-09-17 15:00:07 -07002081 }
Michael Jurkaa63c4522010-08-19 13:52:27 -07002082
Adam Cohenad4e15c2013-10-17 16:21:35 -07002083 void addAppWidgetImpl(final int appWidgetId, final ItemInfo info,
2084 final AppWidgetHostView boundWidget, final AppWidgetProviderInfo appWidgetInfo) {
2085 addAppWidgetImpl(appWidgetId, info, boundWidget, appWidgetInfo, 0);
2086 }
2087
2088 void addAppWidgetImpl(final int appWidgetId, final ItemInfo info,
2089 final AppWidgetHostView boundWidget, final AppWidgetProviderInfo appWidgetInfo, int
2090 delay) {
Adam Cohen9d5b7d82012-05-09 18:00:44 -07002091 if (appWidgetInfo.configure != null) {
2092 mPendingAddWidgetInfo = appWidgetInfo;
Adam Cohen4637b5a2013-11-04 18:21:24 -08002093 mPendingAddWidgetId = appWidgetId;
Michael Jurkaaf442092010-06-10 17:01:57 -07002094
Bjorn Bringert7984c942009-12-09 15:38:25 +00002095 // Launch over to configure widget, if needed
2096 Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_CONFIGURE);
Adam Cohen9d5b7d82012-05-09 18:00:44 -07002097 intent.setComponent(appWidgetInfo.configure);
Bjorn Bringert7984c942009-12-09 15:38:25 +00002098 intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId);
Michael Jurkaa805e1a2013-08-22 15:00:33 +02002099 Utilities.startActivityForResultSafely(this, intent, REQUEST_CREATE_APPWIDGET);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002100 } else {
Bjorn Bringert7984c942009-12-09 15:38:25 +00002101 // Otherwise just add it
Adam Cohenad4e15c2013-10-17 16:21:35 -07002102 Runnable onComplete = new Runnable() {
2103 @Override
2104 public void run() {
2105 // Exit spring loaded mode if necessary after adding the widget
2106 exitSpringLoadedDragModeDelayed(true, EXIT_SPRINGLOADED_MODE_SHORT_TIMEOUT,
2107 null);
2108 }
2109 };
Adam Cohendcd297f2013-06-18 13:13:40 -07002110 completeAddAppWidget(appWidgetId, info.container, info.screenId, boundWidget,
Adam Cohen9d5b7d82012-05-09 18:00:44 -07002111 appWidgetInfo);
Adam Cohenad4e15c2013-10-17 16:21:35 -07002112 mWorkspace.removeExtraEmptyScreen(true, onComplete, delay, false);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002113 }
2114 }
Romain Guycbb89e42009-06-08 15:52:54 -07002115
Allan Wojciechowskiaf110e82013-09-12 10:48:23 +01002116 protected void moveToCustomContentScreen(boolean animate) {
Sandeep Siddharthaf2b47f12013-09-26 19:49:27 -07002117 // Close any folders that may be open.
2118 closeFolder();
Allan Wojciechowskiaf110e82013-09-12 10:48:23 +01002119 mWorkspace.moveToCustomContentScreen(animate);
2120 }
Adam Cohenfbba09b2011-07-18 21:43:05 -07002121 /**
2122 * Process a shortcut drop.
2123 *
2124 * @param componentName The name of the component
Adam Cohendcd297f2013-06-18 13:13:40 -07002125 * @param screenId The ID of the screen where it should be added
Adam Cohenfbba09b2011-07-18 21:43:05 -07002126 * @param cell The cell it should be added to, optional
2127 * @param position The location on the screen where it was dropped, optional
2128 */
Adam Cohendcd297f2013-06-18 13:13:40 -07002129 void processShortcutFromDrop(ComponentName componentName, long container, long screenId,
Winson Chung3d503fb2011-07-13 17:25:49 -07002130 int[] cell, int[] loc) {
Michael Jurka0280c3b2010-09-17 15:00:07 -07002131 resetAddInfo();
Winson Chung3d503fb2011-07-13 17:25:49 -07002132 mPendingAddInfo.container = container;
Adam Cohendcd297f2013-06-18 13:13:40 -07002133 mPendingAddInfo.screenId = screenId;
Winson Chung3d503fb2011-07-13 17:25:49 -07002134 mPendingAddInfo.dropPos = loc;
Adam Cohenfbba09b2011-07-18 21:43:05 -07002135
2136 if (cell != null) {
Winson Chung3d503fb2011-07-13 17:25:49 -07002137 mPendingAddInfo.cellX = cell[0];
2138 mPendingAddInfo.cellY = cell[1];
Adam Cohenfbba09b2011-07-18 21:43:05 -07002139 }
Michael Jurka0280c3b2010-09-17 15:00:07 -07002140
2141 Intent createShortcutIntent = new Intent(Intent.ACTION_CREATE_SHORTCUT);
2142 createShortcutIntent.setComponent(componentName);
2143 processShortcut(createShortcutIntent);
2144 }
2145
Adam Cohenfbba09b2011-07-18 21:43:05 -07002146 /**
2147 * Process a widget drop.
2148 *
2149 * @param info The PendingAppWidgetInfo of the widget being added.
Adam Cohendcd297f2013-06-18 13:13:40 -07002150 * @param screenId The ID of the screen where it should be added
Adam Cohenfbba09b2011-07-18 21:43:05 -07002151 * @param cell The cell it should be added to, optional
2152 * @param position The location on the screen where it was dropped, optional
2153 */
Adam Cohendcd297f2013-06-18 13:13:40 -07002154 void addAppWidgetFromDrop(PendingAddWidgetInfo info, long container, long screenId,
Adam Cohend41fbf52012-02-16 23:53:59 -08002155 int[] cell, int[] span, int[] loc) {
Adam Cohenfbba09b2011-07-18 21:43:05 -07002156 resetAddInfo();
Winson Chung3d503fb2011-07-13 17:25:49 -07002157 mPendingAddInfo.container = info.container = container;
Adam Cohendcd297f2013-06-18 13:13:40 -07002158 mPendingAddInfo.screenId = info.screenId = screenId;
Winson Chung3d503fb2011-07-13 17:25:49 -07002159 mPendingAddInfo.dropPos = loc;
Adam Cohend41fbf52012-02-16 23:53:59 -08002160 mPendingAddInfo.minSpanX = info.minSpanX;
2161 mPendingAddInfo.minSpanY = info.minSpanY;
2162
Adam Cohenfbba09b2011-07-18 21:43:05 -07002163 if (cell != null) {
Winson Chung3d503fb2011-07-13 17:25:49 -07002164 mPendingAddInfo.cellX = cell[0];
2165 mPendingAddInfo.cellY = cell[1];
Adam Cohenfbba09b2011-07-18 21:43:05 -07002166 }
Adam Cohend41fbf52012-02-16 23:53:59 -08002167 if (span != null) {
2168 mPendingAddInfo.spanX = span[0];
2169 mPendingAddInfo.spanY = span[1];
2170 }
Adam Cohenfbba09b2011-07-18 21:43:05 -07002171
Adam Cohened66b2b2012-01-23 17:28:51 -08002172 AppWidgetHostView hostView = info.boundWidget;
2173 int appWidgetId;
2174 if (hostView != null) {
2175 appWidgetId = hostView.getAppWidgetId();
Adam Cohen9d5b7d82012-05-09 18:00:44 -07002176 addAppWidgetImpl(appWidgetId, info, hostView, info.info);
Adam Cohened66b2b2012-01-23 17:28:51 -08002177 } else {
Adam Cohen9d5b7d82012-05-09 18:00:44 -07002178 // In this case, we either need to start an activity to get permission to bind
2179 // the widget, or we need to start an activity to configure the widget, or both.
Adam Cohened66b2b2012-01-23 17:28:51 -08002180 appWidgetId = getAppWidgetHost().allocateAppWidgetId();
Adam Cohendd70d662012-10-04 16:53:44 -07002181 Bundle options = info.bindOptions;
2182
2183 boolean success = false;
2184 if (options != null) {
2185 success = mAppWidgetManager.bindAppWidgetIdIfAllowed(appWidgetId,
2186 info.componentName, options);
2187 } else {
2188 success = mAppWidgetManager.bindAppWidgetIdIfAllowed(appWidgetId,
2189 info.componentName);
2190 }
2191 if (success) {
Adam Cohen9d5b7d82012-05-09 18:00:44 -07002192 addAppWidgetImpl(appWidgetId, info, null, info.info);
Michael Jurka8b805b12012-04-18 14:23:14 -07002193 } else {
Adam Cohen9d5b7d82012-05-09 18:00:44 -07002194 mPendingAddWidgetInfo = info.info;
Michael Jurka8b805b12012-04-18 14:23:14 -07002195 Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_BIND);
2196 intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId);
2197 intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_PROVIDER, info.componentName);
Adam Cohendd70d662012-10-04 16:53:44 -07002198 // TODO: we need to make sure that this accounts for the options bundle.
2199 // intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_OPTIONS, options);
Michael Jurka8b805b12012-04-18 14:23:14 -07002200 startActivityForResult(intent, REQUEST_BIND_APPWIDGET);
2201 }
Adam Cohened66b2b2012-01-23 17:28:51 -08002202 }
Adam Cohenfbba09b2011-07-18 21:43:05 -07002203 }
2204
Joe Onoratodeb98af2010-02-19 14:59:39 -08002205 void processShortcut(Intent intent) {
Jeffrey Sharkeyc7fdae12009-03-24 20:41:22 -07002206 // Handle case where user selected "Applications"
2207 String applicationName = getResources().getString(R.string.group_applications);
2208 String shortcutName = intent.getStringExtra(Intent.EXTRA_SHORTCUT_NAME);
Romain Guycbb89e42009-06-08 15:52:54 -07002209
Jeffrey Sharkeyc7fdae12009-03-24 20:41:22 -07002210 if (applicationName != null && applicationName.equals(shortcutName)) {
2211 Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
2212 mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);
Romain Guycbb89e42009-06-08 15:52:54 -07002213
Jeffrey Sharkeyc7fdae12009-03-24 20:41:22 -07002214 Intent pickIntent = new Intent(Intent.ACTION_PICK_ACTIVITY);
2215 pickIntent.putExtra(Intent.EXTRA_INTENT, mainIntent);
Winson Chung58f20882010-10-01 13:44:56 -07002216 pickIntent.putExtra(Intent.EXTRA_TITLE, getText(R.string.title_select_application));
Michael Jurkaa805e1a2013-08-22 15:00:33 +02002217 Utilities.startActivityForResultSafely(this, pickIntent, REQUEST_PICK_APPLICATION);
Jeffrey Sharkeyc7fdae12009-03-24 20:41:22 -07002218 } else {
Michael Jurkaa805e1a2013-08-22 15:00:33 +02002219 Utilities.startActivityForResultSafely(this, intent, REQUEST_CREATE_SHORTCUT);
Jeffrey Sharkeyc7fdae12009-03-24 20:41:22 -07002220 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002221 }
2222
Winson Chung24ab2f12010-09-16 14:10:47 -07002223 void processWallpaper(Intent intent) {
2224 startActivityForResult(intent, REQUEST_PICK_WALLPAPER);
2225 }
2226
Adam Cohendcd297f2013-06-18 13:13:40 -07002227 FolderIcon addFolder(CellLayout layout, long container, final long screenId, int cellX,
Winson Chung3d503fb2011-07-13 17:25:49 -07002228 int cellY) {
Michael Jurkac9d95c52011-08-29 14:03:34 -07002229 final FolderInfo folderInfo = new FolderInfo();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002230 folderInfo.title = getText(R.string.folder_name);
2231
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002232 // Update the model
Adam Cohendcd297f2013-06-18 13:13:40 -07002233 LauncherModel.addItemToDatabase(Launcher.this, folderInfo, container, screenId, cellX, cellY,
Winson Chung3d503fb2011-07-13 17:25:49 -07002234 false);
Brad Fitzpatrick319226a2010-09-01 13:45:16 -07002235 sFolders.put(folderInfo.id, folderInfo);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002236
2237 // Create the view
Winson Chung3d503fb2011-07-13 17:25:49 -07002238 FolderIcon newFolder =
2239 FolderIcon.fromXml(R.layout.folder_icon, this, layout, folderInfo, mIconCache);
Adam Cohendcd297f2013-06-18 13:13:40 -07002240 mWorkspace.addInScreen(newFolder, container, screenId, cellX, cellY, 1, 1,
Winson Chung3d503fb2011-07-13 17:25:49 -07002241 isWorkspaceLocked());
Winson Chung5f8afe62013-08-12 16:19:28 -07002242 // Force measure the new folder icon
2243 CellLayout parent = mWorkspace.getParentCellLayoutForView(newFolder);
2244 parent.getShortcutsAndWidgets().measureChild(newFolder);
Adam Cohendf035382011-04-11 17:22:04 -07002245 return newFolder;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002246 }
Romain Guycbb89e42009-06-08 15:52:54 -07002247
Joe Onorato9c1289c2009-08-17 11:03:03 -04002248 void removeFolder(FolderInfo folder) {
Brad Fitzpatrick319226a2010-09-01 13:45:16 -07002249 sFolders.remove(folder.id);
Joe Onorato9c1289c2009-08-17 11:03:03 -04002250 }
2251
Michael Jurkaeadbfc52013-09-04 00:45:37 +02002252 protected void startWallpaper() {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002253 final Intent pickWallpaper = new Intent(Intent.ACTION_SET_WALLPAPER);
Michael Jurkaeadbfc52013-09-04 00:45:37 +02002254 pickWallpaper.setComponent(getWallpaperPickerComponent());
Michael Jurka104c4562013-07-08 18:03:46 -07002255 startActivityForResult(pickWallpaper, REQUEST_PICK_WALLPAPER);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002256 }
2257
Michael Jurkaeadbfc52013-09-04 00:45:37 +02002258 protected ComponentName getWallpaperPickerComponent() {
Michael Jurka7ad868b2013-12-12 15:04:25 +01002259 return new ComponentName(getPackageName(), LauncherWallpaperPickerActivity.class.getName());
Michael Jurkaeadbfc52013-09-04 00:45:37 +02002260 }
2261
Joe Onorato2ca0ae72009-11-10 13:14:13 -08002262 /**
2263 * Registers various content observers. The current implementation registers
2264 * only a favorites observer to keep track of the favorites applications.
2265 */
Jeff Sharkey1e2efc82009-11-06 15:17:59 -08002266 private void registerContentObservers() {
2267 ContentResolver resolver = getContentResolver();
2268 resolver.registerContentObserver(LauncherProvider.CONTENT_APPWIDGET_RESET_URI,
2269 true, mWidgetObserver);
2270 }
2271
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002272 @Override
2273 public boolean dispatchKeyEvent(KeyEvent event) {
2274 if (event.getAction() == KeyEvent.ACTION_DOWN) {
2275 switch (event.getKeyCode()) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002276 case KeyEvent.KEYCODE_HOME:
Dianne Hackborn67800862009-07-24 17:15:20 -07002277 return true;
Joe Onoratobe386092009-11-17 17:32:16 -08002278 case KeyEvent.KEYCODE_VOLUME_DOWN:
Michael Jurka0a457bf2012-11-19 14:05:05 -08002279 if (isPropertyEnabled(DUMP_STATE_PROPERTY)) {
Joe Onoratobe386092009-11-17 17:32:16 -08002280 dumpState();
2281 return true;
2282 }
2283 break;
Dianne Hackborn67800862009-07-24 17:15:20 -07002284 }
2285 } else if (event.getAction() == KeyEvent.ACTION_UP) {
2286 switch (event.getKeyCode()) {
Dianne Hackborn67800862009-07-24 17:15:20 -07002287 case KeyEvent.KEYCODE_HOME:
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002288 return true;
2289 }
2290 }
2291
2292 return super.dispatchKeyEvent(event);
2293 }
2294
Joe Onorato88ec0992009-11-19 13:16:06 -08002295 @Override
2296 public void onBackPressed() {
Winson Chungc93e5ae2012-07-23 20:48:26 -07002297 if (isAllAppsVisible()) {
Adam Cohened307df2013-10-02 09:37:31 -07002298 if (mAppsCustomizeContent.getContentType() ==
2299 AppsCustomizePagedView.ContentType.Applications) {
2300 showWorkspace(true);
2301 } else {
2302 showOverviewMode(true);
2303 }
Adam Cohenf358a4b2013-07-23 16:47:31 -07002304 } else if (mWorkspace.isInOverviewMode()) {
Michael Jurka336fd4f2013-09-12 00:05:02 +02002305 mWorkspace.exitOverviewMode(true);
Patrick Dubroy94f78a52011-02-28 17:39:16 -08002306 } else if (mWorkspace.getOpenFolder() != null) {
Adam Cohen76fc0852011-06-17 13:26:23 -07002307 Folder openFolder = mWorkspace.getOpenFolder();
2308 if (openFolder.isEditingName()) {
2309 openFolder.dismissEditingName();
2310 } else {
2311 closeFolder();
2312 }
Patrick Dubroy94f78a52011-02-28 17:39:16 -08002313 } else {
Patrick Dubroy758a9232011-03-03 19:54:56 -08002314 mWorkspace.exitWidgetResizeMode();
2315
Patrick Dubroy94f78a52011-02-28 17:39:16 -08002316 // Back button is a no-op here, but give at least some feedback for the button press
2317 mWorkspace.showOutlinesTemporarily();
Michael Jurkaaf442092010-06-10 17:01:57 -07002318 }
Joe Onorato88ec0992009-11-19 13:16:06 -08002319 }
2320
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002321 /**
Jeff Sharkey1e2efc82009-11-06 15:17:59 -08002322 * Re-listen when widgets are reset.
2323 */
2324 private void onAppWidgetReset() {
Michael Jurkabbbad6b2011-02-07 13:04:09 -08002325 if (mAppWidgetHost != null) {
2326 mAppWidgetHost.startListening();
2327 }
Jeff Sharkey1e2efc82009-11-06 15:17:59 -08002328 }
2329
2330 /**
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002331 * Launches the intent referred by the clicked shortcut.
2332 *
2333 * @param v The view representing the clicked shortcut.
2334 */
2335 public void onClick(View v) {
Adam Cohen9932a9b2011-08-02 22:14:07 -07002336 // Make sure that rogue clicks don't get through while allapps is launching, or after the
2337 // view has detached (it's possible for this to happen if the view is removed mid touch).
2338 if (v.getWindowToken() == null) {
2339 return;
2340 }
2341
Winson Chung9b0b2fe2012-02-24 13:03:34 -08002342 if (!mWorkspace.isFinishedSwitchingState()) {
Adam Cohen9932a9b2011-08-02 22:14:07 -07002343 return;
2344 }
Adam Cohen2f84ef22011-07-26 17:16:44 -07002345
Adam Cohen1697b792013-09-17 19:08:21 -07002346 if (v instanceof Workspace) {
2347 if (mWorkspace.isInOverviewMode()) {
2348 mWorkspace.exitOverviewMode(true);
Adam Cohenf358a4b2013-07-23 16:47:31 -07002349 }
2350 return;
2351 }
2352
2353 if (v instanceof CellLayout) {
2354 if (mWorkspace.isInOverviewMode()) {
Michael Jurka336fd4f2013-09-12 00:05:02 +02002355 mWorkspace.exitOverviewMode(mWorkspace.indexOfChild(v), true);
Adam Cohenf358a4b2013-07-23 16:47:31 -07002356 }
2357 }
2358
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002359 Object tag = v.getTag();
Joe Onorato0589f0f2010-02-08 13:44:00 -08002360 if (tag instanceof ShortcutInfo) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002361 // Open shortcut
Daniel Sandlerff02d492013-08-05 02:12:05 -04002362 final ShortcutInfo shortcut = (ShortcutInfo) tag;
2363 final Intent intent = shortcut.intent;
Adam Cohenb5fe60c2013-06-06 22:03:51 -07002364
Daniel Sandlerf8577a32013-06-26 14:04:59 -04002365 // Check for special shortcuts
2366 if (intent.getComponent() != null) {
2367 final String shortcutClass = intent.getComponent().getClassName();
2368
2369 if (shortcutClass.equals(WidgetAdder.class.getName())) {
Winson Chung82963d52013-10-09 11:20:57 -07002370 showAllApps(true, AppsCustomizePagedView.ContentType.Widgets, true);
Daniel Sandlerf8577a32013-06-26 14:04:59 -04002371 return;
2372 } else if (shortcutClass.equals(MemoryDumpActivity.class.getName())) {
2373 MemoryDumpActivity.startDump(this);
2374 return;
Adam Cohen39a06042013-07-19 14:30:12 -07002375 } else if (shortcutClass.equals(ToggleWeightWatcher.class.getName())) {
2376 toggleShowWeightWatcher();
2377 return;
Daniel Sandlerf8577a32013-06-26 14:04:59 -04002378 }
Adam Cohenb5fe60c2013-06-06 22:03:51 -07002379 }
Daniel Sandlerf8577a32013-06-26 14:04:59 -04002380
2381 // Start activities
Joe Onorato13724ea2009-12-02 21:16:35 -08002382 int[] pos = new int[2];
2383 v.getLocationOnScreen(pos);
Romain Guyfb5411e2010-02-24 10:04:17 -08002384 intent.setSourceBounds(new Rect(pos[0], pos[1],
2385 pos[0] + v.getWidth(), pos[1] + v.getHeight()));
Winson Chungc7450e32012-04-17 17:34:08 -07002386
2387 boolean success = startActivitySafely(v, intent, tag);
Michael Jurkaddd62e92011-02-16 17:49:14 -08002388
Daniel Sandlerff02d492013-08-05 02:12:05 -04002389 mStats.recordLaunch(intent, shortcut);
2390
Michael Jurkaddd62e92011-02-16 17:49:14 -08002391 if (success && v instanceof BubbleTextView) {
2392 mWaitingForResume = (BubbleTextView) v;
2393 mWaitingForResume.setStayPressed(true);
2394 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002395 } else if (tag instanceof FolderInfo) {
Adam Cohena9cf38f2011-05-02 15:36:58 -07002396 if (v instanceof FolderIcon) {
2397 FolderIcon fi = (FolderIcon) v;
2398 handleFolderClick(fi);
2399 }
Winson Chungf0ea4d32011-06-06 14:27:16 -07002400 } else if (v == mAllAppsButton) {
Winson Chungc93e5ae2012-07-23 20:48:26 -07002401 if (isAllAppsVisible()) {
Michael Jurkac0e8fca2010-10-06 16:41:29 -07002402 showWorkspace(true);
Joe Onorato7404ee42009-07-31 11:54:44 -07002403 } else {
Michael Jurka2a552322011-10-11 15:22:05 -07002404 onClickAllAppsButton(v);
Joe Onorato7404ee42009-07-31 11:54:44 -07002405 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002406 }
2407 }
2408
Michael Jurka0e260592010-06-30 17:07:39 -07002409 public boolean onTouch(View v, MotionEvent event) {
Michael Jurka0e260592010-06-30 17:07:39 -07002410 return false;
2411 }
2412
Michael Jurkaaf442092010-06-10 17:01:57 -07002413 /**
Michael Jurka2c3af5f2010-08-03 13:53:20 -07002414 * Event handler for the search button
2415 *
2416 * @param v The view that was clicked.
2417 */
2418 public void onClickSearchButton(View v) {
Winson Chungbb185bd2011-11-21 12:31:42 -08002419 v.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY);
2420
Amith Yamasania135ba82011-08-09 17:42:01 -07002421 onSearchRequested();
Michael Jurka2c3af5f2010-08-03 13:53:20 -07002422 }
2423
2424 /**
Amith Yamasani6d7fe502010-11-16 09:05:07 -08002425 * Event handler for the voice button
2426 *
2427 * @param v The view that was clicked.
2428 */
2429 public void onClickVoiceButton(View v) {
Winson Chungbb185bd2011-11-21 12:31:42 -08002430 v.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY);
Amith Yamasani6d7fe502010-11-16 09:05:07 -08002431
Bjorn Bringertc459e522013-06-07 19:36:01 +01002432 startVoice();
2433 }
2434
2435 public void startVoice() {
Michael Jurkaae65ee32012-04-30 11:45:54 -07002436 try {
2437 final SearchManager searchManager =
2438 (SearchManager) getSystemService(Context.SEARCH_SERVICE);
2439 ComponentName activityName = searchManager.getGlobalSearchActivity();
2440 Intent intent = new Intent(RecognizerIntent.ACTION_WEB_SEARCH);
Andy Huangf615f712012-06-07 13:38:04 -07002441 intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
Michael Jurkaae65ee32012-04-30 11:45:54 -07002442 if (activityName != null) {
2443 intent.setPackage(activityName.getPackageName());
2444 }
Michael Jurka86a720e2012-05-09 11:23:23 -07002445 startActivity(null, intent, "onClickVoiceButton");
Michael Jurkaae65ee32012-04-30 11:45:54 -07002446 } catch (ActivityNotFoundException e) {
2447 Intent intent = new Intent(RecognizerIntent.ACTION_WEB_SEARCH);
Andy Huangf615f712012-06-07 13:38:04 -07002448 intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
Michael Jurkaae65ee32012-04-30 11:45:54 -07002449 startActivitySafely(null, intent, "onClickVoiceButton");
2450 }
Amith Yamasani6d7fe502010-11-16 09:05:07 -08002451 }
2452
2453 /**
Michael Jurka2c3af5f2010-08-03 13:53:20 -07002454 * Event handler for the "grid" button that appears on the home screen, which
2455 * enters all apps mode.
2456 *
2457 * @param v The view that was clicked.
2458 */
2459 public void onClickAllAppsButton(View v) {
Winson Chunge7e97e62013-12-02 17:02:50 -08002460 showAllApps(true, AppsCustomizePagedView.ContentType.Applications, false);
Michael Jurka5130e402011-10-13 04:55:35 -07002461 }
2462
2463 public void onTouchDownAllAppsButton(View v) {
Michael Jurka2a552322011-10-11 15:22:05 -07002464 // Provide the same haptic feedback that the system offers for virtual keys.
2465 v.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY);
Michael Jurka2c3af5f2010-08-03 13:53:20 -07002466 }
2467
Adam Cohen61f560d2013-09-30 15:58:20 -07002468 public void performHapticFeedbackOnTouchDown(View v) {
2469 // Provide the same haptic feedback that the system offers for virtual keys.
2470 v.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY);
2471 }
2472
2473 public View.OnTouchListener getHapticFeedbackTouchListener() {
2474 if (mHapticFeedbackTouchListener == null) {
2475 mHapticFeedbackTouchListener = new View.OnTouchListener() {
2476 @Override
2477 public boolean onTouch(View v, MotionEvent event) {
2478 if ((event.getAction() & MotionEvent.ACTION_MASK) == MotionEvent.ACTION_DOWN) {
2479 v.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY);
2480 }
2481 return false;
2482 }
2483 };
2484 }
2485 return mHapticFeedbackTouchListener;
2486 }
2487
Patrick Dubroyceae05d2010-08-30 10:40:53 -07002488 public void onClickAppMarketButton(View v) {
Winson Chungd64a6662013-09-30 11:06:59 -07002489 if (!DISABLE_MARKET_BUTTON) {
2490 if (mAppMarketIntent != null) {
2491 startActivitySafely(v, mAppMarketIntent, "app market");
2492 } else {
2493 Log.e(TAG, "Invalid app market intent.");
2494 }
Patrick Dubroyceae05d2010-08-30 10:40:53 -07002495 }
2496 }
2497
Sandeep Siddharthaab2d9d72013-09-17 13:18:24 -07002498 /**
2499 * Called when the user stops interacting with the launcher.
2500 * This implies that the user is now on the homescreen and is not doing housekeeping.
2501 */
2502 protected void onInteractionEnd() {}
2503
2504 /**
2505 * Called when the user starts interacting with the launcher.
2506 * The possible interactions are:
2507 * - open all apps
2508 * - reorder an app shortcut, or a widget
2509 * - open the overview mode.
2510 * This is a good time to stop doing things that only make sense
2511 * when the user is on the homescreen and not doing housekeeping.
2512 */
2513 protected void onInteractionBegin() {}
2514
Patrick Dubroybc6840b2010-09-01 11:54:27 -07002515 void startApplicationDetailsActivity(ComponentName componentName) {
2516 String packageName = componentName.getPackageName();
Patrick Dubroy4ed62782010-08-17 15:11:18 -07002517 Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
2518 Uri.fromParts("package", packageName, null));
Adrian Roos850f9132014-01-13 17:44:52 -08002519 intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK |
2520 Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
Winson Chung3b1b36b2012-04-24 18:51:14 -07002521 startActivitySafely(null, intent, "startApplicationDetailsActivity");
Patrick Dubroy4ed62782010-08-17 15:11:18 -07002522 }
2523
Michael Jurka1e2f4652013-07-08 18:03:46 -07002524 // returns true if the activity was started
2525 boolean startApplicationUninstallActivity(ComponentName componentName, int flags) {
Michael Jurkaeadbfc52013-09-04 00:45:37 +02002526 if ((flags & AppInfo.DOWNLOADED_FLAG) == 0) {
Patrick Dubroy5539af72010-09-07 15:22:01 -07002527 // System applications cannot be installed. For now, show a toast explaining that.
2528 // We may give them the option of disabling apps this way.
2529 int messageId = R.string.uninstall_system_app_text;
2530 Toast.makeText(this, messageId, Toast.LENGTH_SHORT).show();
Michael Jurka1e2f4652013-07-08 18:03:46 -07002531 return false;
Patrick Dubroy5539af72010-09-07 15:22:01 -07002532 } else {
Michael Jurka1e2f4652013-07-08 18:03:46 -07002533 String packageName = componentName.getPackageName();
2534 String className = componentName.getClassName();
Patrick Dubroy5539af72010-09-07 15:22:01 -07002535 Intent intent = new Intent(
2536 Intent.ACTION_DELETE, Uri.fromParts("package", packageName, className));
Winson Chungdff8ebb2011-09-08 17:25:31 -07002537 intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK |
2538 Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
Patrick Dubroy5539af72010-09-07 15:22:01 -07002539 startActivity(intent);
Michael Jurka1e2f4652013-07-08 18:03:46 -07002540 return true;
Patrick Dubroy5539af72010-09-07 15:22:01 -07002541 }
Patrick Dubroybc6840b2010-09-01 11:54:27 -07002542 }
2543
Michael Jurka86a720e2012-05-09 11:23:23 -07002544 boolean startActivity(View v, Intent intent, Object tag) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002545 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
Winson Chungc7450e32012-04-17 17:34:08 -07002546
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002547 try {
Winson Chung2672ff92012-05-04 16:22:30 -07002548 // Only launch using the new animation if the shortcut has not opted out (this is a
2549 // private contract between launcher and may be ignored in the future).
2550 boolean useLaunchAnimation = (v != null) &&
2551 !intent.hasExtra(INTENT_EXTRA_IGNORE_LAUNCH_ANIMATION);
2552 if (useLaunchAnimation) {
Winson Chungc7450e32012-04-17 17:34:08 -07002553 ActivityOptions opts = ActivityOptions.makeScaleUpAnimation(v, 0, 0,
2554 v.getMeasuredWidth(), v.getMeasuredHeight());
2555
2556 startActivity(intent, opts.toBundle());
2557 } else {
2558 startActivity(intent);
2559 }
Michael Jurkaddd62e92011-02-16 17:49:14 -08002560 return true;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002561 } catch (SecurityException e) {
2562 Toast.makeText(this, R.string.activity_not_found, Toast.LENGTH_SHORT).show();
Joe Onoratoa30ce8e2009-11-11 08:16:49 -08002563 Log.e(TAG, "Launcher does not have the permission to launch " + intent +
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002564 ". Make sure to create a MAIN intent-filter for the corresponding activity " +
Joe Onoratof984e852010-03-25 09:47:45 -07002565 "or use the exported attribute for this activity. "
2566 + "tag="+ tag + " intent=" + intent, e);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002567 }
Michael Jurkaddd62e92011-02-16 17:49:14 -08002568 return false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002569 }
Winson Chungaafa03c2010-06-11 17:34:16 -07002570
Michael Jurka86a720e2012-05-09 11:23:23 -07002571 boolean startActivitySafely(View v, Intent intent, Object tag) {
2572 boolean success = false;
2573 try {
2574 success = startActivity(v, intent, tag);
2575 } catch (ActivityNotFoundException e) {
2576 Toast.makeText(this, R.string.activity_not_found, Toast.LENGTH_SHORT).show();
2577 Log.e(TAG, "Unable to launch. tag=" + tag + " intent=" + intent, e);
2578 }
2579 return success;
2580 }
2581
Adam Cohena9cf38f2011-05-02 15:36:58 -07002582 private void handleFolderClick(FolderIcon folderIcon) {
Adam Cohenfb91f302012-06-11 15:45:18 -07002583 final FolderInfo info = folderIcon.getFolderInfo();
Adam Cohen3c81a382011-08-31 22:25:51 -07002584 Folder openFolder = mWorkspace.getFolderForTag(info);
2585
2586 // If the folder info reports that the associated folder is open, then verify that
2587 // it is actually opened. There have been a few instances where this gets out of sync.
2588 if (info.opened && openFolder == null) {
2589 Log.d(TAG, "Folder info marked as open, but associated folder is not open. Screen: "
Adam Cohendcd297f2013-06-18 13:13:40 -07002590 + info.screenId + " (" + info.cellX + ", " + info.cellY + ")");
Adam Cohen3c81a382011-08-31 22:25:51 -07002591 info.opened = false;
2592 }
2593
Adam Cohenfb91f302012-06-11 15:45:18 -07002594 if (!info.opened && !folderIcon.getFolder().isDestroyed()) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002595 // Close any open folder
2596 closeFolder();
2597 // Open the requested folder
Adam Cohena9cf38f2011-05-02 15:36:58 -07002598 openFolder(folderIcon);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002599 } else {
2600 // Find the open folder...
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002601 int folderScreen;
2602 if (openFolder != null) {
Michael Jurka0142d492010-08-25 17:46:15 -07002603 folderScreen = mWorkspace.getPageForView(openFolder);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002604 // .. and close it
2605 closeFolder(openFolder);
Michael Jurka0142d492010-08-25 17:46:15 -07002606 if (folderScreen != mWorkspace.getCurrentPage()) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002607 // Close any folder open on the current screen
2608 closeFolder();
2609 // Pull the folder onto this screen
Adam Cohena9cf38f2011-05-02 15:36:58 -07002610 openFolder(folderIcon);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002611 }
2612 }
2613 }
2614 }
2615
Adam Cohen268c4752012-06-06 17:47:33 -07002616 /**
2617 * This method draws the FolderIcon to an ImageView and then adds and positions that ImageView
2618 * in the DragLayer in the exact absolute location of the original FolderIcon.
2619 */
2620 private void copyFolderIconToImage(FolderIcon fi) {
2621 final int width = fi.getMeasuredWidth();
2622 final int height = fi.getMeasuredHeight();
2623
2624 // Lazy load ImageView, Bitmap and Canvas
2625 if (mFolderIconImageView == null) {
2626 mFolderIconImageView = new ImageView(this);
2627 }
2628 if (mFolderIconBitmap == null || mFolderIconBitmap.getWidth() != width ||
2629 mFolderIconBitmap.getHeight() != height) {
2630 mFolderIconBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
2631 mFolderIconCanvas = new Canvas(mFolderIconBitmap);
2632 }
2633
2634 DragLayer.LayoutParams lp;
2635 if (mFolderIconImageView.getLayoutParams() instanceof DragLayer.LayoutParams) {
2636 lp = (DragLayer.LayoutParams) mFolderIconImageView.getLayoutParams();
2637 } else {
2638 lp = new DragLayer.LayoutParams(width, height);
2639 }
2640
Adam Cohen307fe232012-08-16 17:55:58 -07002641 // The layout from which the folder is being opened may be scaled, adjust the starting
2642 // view size by this scale factor.
2643 float scale = mDragLayer.getDescendantRectRelativeToSelf(fi, mRectForFolderAnimation);
Adam Cohen268c4752012-06-06 17:47:33 -07002644 lp.customPosition = true;
2645 lp.x = mRectForFolderAnimation.left;
2646 lp.y = mRectForFolderAnimation.top;
Adam Cohen307fe232012-08-16 17:55:58 -07002647 lp.width = (int) (scale * width);
2648 lp.height = (int) (scale * height);
Adam Cohen268c4752012-06-06 17:47:33 -07002649
2650 mFolderIconCanvas.drawColor(0, PorterDuff.Mode.CLEAR);
2651 fi.draw(mFolderIconCanvas);
2652 mFolderIconImageView.setImageBitmap(mFolderIconBitmap);
Adam Cohenfb91f302012-06-11 15:45:18 -07002653 if (fi.getFolder() != null) {
2654 mFolderIconImageView.setPivotX(fi.getFolder().getPivotXForIconAnimation());
2655 mFolderIconImageView.setPivotY(fi.getFolder().getPivotYForIconAnimation());
Adam Cohen8ec23032012-06-08 14:46:22 -07002656 }
Adam Cohen268c4752012-06-06 17:47:33 -07002657 // Just in case this image view is still in the drag layer from a previous animation,
2658 // we remove it and re-add it.
2659 if (mDragLayer.indexOfChild(mFolderIconImageView) != -1) {
2660 mDragLayer.removeView(mFolderIconImageView);
2661 }
2662 mDragLayer.addView(mFolderIconImageView, lp);
Adam Cohenfb91f302012-06-11 15:45:18 -07002663 if (fi.getFolder() != null) {
2664 fi.getFolder().bringToFront();
Adam Cohen8ec23032012-06-08 14:46:22 -07002665 }
Adam Cohen268c4752012-06-06 17:47:33 -07002666 }
2667
Adam Cohen2801caf2011-05-13 20:57:39 -07002668 private void growAndFadeOutFolderIcon(FolderIcon fi) {
Adam Cohen9932a9b2011-08-02 22:14:07 -07002669 if (fi == null) return;
Adam Cohen2801caf2011-05-13 20:57:39 -07002670 PropertyValuesHolder alpha = PropertyValuesHolder.ofFloat("alpha", 0);
2671 PropertyValuesHolder scaleX = PropertyValuesHolder.ofFloat("scaleX", 1.5f);
2672 PropertyValuesHolder scaleY = PropertyValuesHolder.ofFloat("scaleY", 1.5f);
2673
Adam Cohenc51934b2011-07-26 21:07:43 -07002674 FolderInfo info = (FolderInfo) fi.getTag();
2675 if (info.container == LauncherSettings.Favorites.CONTAINER_HOTSEAT) {
2676 CellLayout cl = (CellLayout) fi.getParent().getParent();
Winson Chunge50adee2011-08-11 16:12:00 -07002677 CellLayout.LayoutParams lp = (CellLayout.LayoutParams) fi.getLayoutParams();
2678 cl.setFolderLeaveBehindCell(lp.cellX, lp.cellY);
Adam Cohenc51934b2011-07-26 21:07:43 -07002679 }
2680
Adam Cohen268c4752012-06-06 17:47:33 -07002681 // Push an ImageView copy of the FolderIcon into the DragLayer and hide the original
2682 copyFolderIconToImage(fi);
2683 fi.setVisibility(View.INVISIBLE);
2684
Michael Jurka2ecf9952012-06-18 12:52:28 -07002685 ObjectAnimator oa = LauncherAnimUtils.ofPropertyValuesHolder(mFolderIconImageView, alpha,
Adam Cohen268c4752012-06-06 17:47:33 -07002686 scaleX, scaleY);
Adam Cohen2801caf2011-05-13 20:57:39 -07002687 oa.setDuration(getResources().getInteger(R.integer.config_folderAnimDuration));
2688 oa.start();
2689 }
2690
Adam Cohen268c4752012-06-06 17:47:33 -07002691 private void shrinkAndFadeInFolderIcon(final FolderIcon fi) {
Adam Cohen9932a9b2011-08-02 22:14:07 -07002692 if (fi == null) return;
Adam Cohen2801caf2011-05-13 20:57:39 -07002693 PropertyValuesHolder alpha = PropertyValuesHolder.ofFloat("alpha", 1.0f);
2694 PropertyValuesHolder scaleX = PropertyValuesHolder.ofFloat("scaleX", 1.0f);
2695 PropertyValuesHolder scaleY = PropertyValuesHolder.ofFloat("scaleY", 1.0f);
2696
Adam Cohen268c4752012-06-06 17:47:33 -07002697 final CellLayout cl = (CellLayout) fi.getParent().getParent();
Adam Cohenc51934b2011-07-26 21:07:43 -07002698
Adam Cohen268c4752012-06-06 17:47:33 -07002699 // We remove and re-draw the FolderIcon in-case it has changed
2700 mDragLayer.removeView(mFolderIconImageView);
2701 copyFolderIconToImage(fi);
Michael Jurka2ecf9952012-06-18 12:52:28 -07002702 ObjectAnimator oa = LauncherAnimUtils.ofPropertyValuesHolder(mFolderIconImageView, alpha,
Adam Cohen268c4752012-06-06 17:47:33 -07002703 scaleX, scaleY);
Adam Cohen2801caf2011-05-13 20:57:39 -07002704 oa.setDuration(getResources().getInteger(R.integer.config_folderAnimDuration));
Adam Cohenc51934b2011-07-26 21:07:43 -07002705 oa.addListener(new AnimatorListenerAdapter() {
2706 @Override
2707 public void onAnimationEnd(Animator animation) {
Adam Cohen268c4752012-06-06 17:47:33 -07002708 if (cl != null) {
2709 cl.clearFolderLeaveBehind();
2710 // Remove the ImageView copy of the FolderIcon and make the original visible.
2711 mDragLayer.removeView(mFolderIconImageView);
2712 fi.setVisibility(View.VISIBLE);
Adam Cohenc51934b2011-07-26 21:07:43 -07002713 }
2714 }
2715 });
Adam Cohen2801caf2011-05-13 20:57:39 -07002716 oa.start();
2717 }
2718
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002719 /**
Michael Jurka774bd372010-10-22 13:40:50 -07002720 * Opens the user folder described by the specified tag. The opening of the folder
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002721 * is animated relative to the specified View. If the View is null, no animation
2722 * is played.
2723 *
2724 * @param folderInfo The FolderInfo describing the folder to open.
2725 */
Adam Cohena9cf38f2011-05-02 15:36:58 -07002726 public void openFolder(FolderIcon folderIcon) {
Adam Cohenfb91f302012-06-11 15:45:18 -07002727 Folder folder = folderIcon.getFolder();
Adam Cohena9cf38f2011-05-02 15:36:58 -07002728 FolderInfo info = folder.mInfo;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002729
Adam Cohena9cf38f2011-05-02 15:36:58 -07002730 info.opened = true;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002731
Adam Cohen4554ee12011-08-03 16:13:21 -07002732 // Just verify that the folder hasn't already been added to the DragLayer.
2733 // There was a one-off crash where the folder had a parent already.
2734 if (folder.getParent() == null) {
2735 mDragLayer.addView(folder);
2736 mDragController.addDropTarget((DropTarget) folder);
2737 } else {
2738 Log.w(TAG, "Opening folder (" + folder + ") which already has a parent (" +
2739 folder.getParent() + ").");
2740 }
Adam Cohena9cf38f2011-05-02 15:36:58 -07002741 folder.animateOpen();
Adam Cohen268c4752012-06-06 17:47:33 -07002742 growAndFadeOutFolderIcon(folderIcon);
Winson Chung83ca4802013-04-12 15:10:52 -07002743
2744 // Notify the accessibility manager that this folder "window" has appeared and occluded
2745 // the workspace items
2746 folder.sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
2747 getDragLayer().sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED);
Adam Cohen4554ee12011-08-03 16:13:21 -07002748 }
2749
2750 public void closeFolder() {
Adam Cohen37c717f2013-11-26 11:50:15 -08002751 Folder folder = mWorkspace != null ? mWorkspace.getOpenFolder() : null;
Adam Cohen4554ee12011-08-03 16:13:21 -07002752 if (folder != null) {
Adam Cohenac56cff2011-09-28 20:45:37 -07002753 if (folder.isEditingName()) {
2754 folder.dismissEditingName();
2755 }
Adam Cohen4554ee12011-08-03 16:13:21 -07002756 closeFolder(folder);
Winson Chung7d7541e2011-09-16 20:14:36 -07002757
2758 // Dismiss the folder cling
Winson Chunga6945242014-01-08 14:04:34 -08002759 mLauncherClings.dismissFolderCling(null);
Adam Cohen4554ee12011-08-03 16:13:21 -07002760 }
2761 }
2762
2763 void closeFolder(Folder folder) {
2764 folder.getInfo().opened = false;
2765
2766 ViewGroup parent = (ViewGroup) folder.getParent().getParent();
2767 if (parent != null) {
2768 FolderIcon fi = (FolderIcon) mWorkspace.getViewForTag(folder.mInfo);
2769 shrinkAndFadeInFolderIcon(fi);
2770 }
2771 folder.animateClosed();
Winson Chung83ca4802013-04-12 15:10:52 -07002772
2773 // Notify the accessibility manager that this folder "window" has disappeard and no
2774 // longer occludeds the workspace items
2775 getDragLayer().sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002776 }
2777
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002778 public boolean onLongClick(View v) {
Winson Chung36a62fe2012-05-06 18:04:42 -07002779 if (!isDraggingEnabled()) return false;
2780 if (isWorkspaceLocked()) return false;
2781 if (mState != State.WORKSPACE) return false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002782
Adam Cohen1697b792013-09-17 19:08:21 -07002783 if (v instanceof Workspace) {
2784 if (!mWorkspace.isInOverviewMode()) {
Adam Cohen93c97562013-09-26 13:48:01 -07002785 if (mWorkspace.enterOverviewMode()) {
2786 mWorkspace.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS,
2787 HapticFeedbackConstants.FLAG_IGNORE_VIEW_SETTING);
2788 return true;
2789 } else {
2790 return false;
2791 }
Adam Cohen1697b792013-09-17 19:08:21 -07002792 }
Adam Cohen1697b792013-09-17 19:08:21 -07002793 }
2794
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002795 if (!(v instanceof CellLayout)) {
Michael Jurka8c920dd2011-01-20 14:16:56 -08002796 v = (View) v.getParent().getParent();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002797 }
2798
Michael Jurka0280c3b2010-09-17 15:00:07 -07002799 resetAddInfo();
2800 CellLayout.CellInfo longClickCellInfo = (CellLayout.CellInfo) v.getTag();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002801 // This happens when long clicking an item with the dpad/trackball
Adam Cohenfaea1f82011-07-21 16:23:57 -07002802 if (longClickCellInfo == null) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002803 return true;
2804 }
2805
Winson Chung3d503fb2011-07-13 17:25:49 -07002806 // The hotseat touch handling does not go through Workspace, and we always allow long press
2807 // on hotseat items.
Michael Jurka0280c3b2010-09-17 15:00:07 -07002808 final View itemUnderLongClick = longClickCellInfo.cell;
Dan Sandlere26d0942014-01-13 14:30:14 -05002809 final boolean inHotseat = isHotseatLayout(v);
2810 boolean allowLongPress = inHotseat || mWorkspace.allowLongPress();
Winson Chung3d503fb2011-07-13 17:25:49 -07002811 if (allowLongPress && !mDragController.isDragging()) {
Michael Jurka0280c3b2010-09-17 15:00:07 -07002812 if (itemUnderLongClick == null) {
Adam Cohend3ecce92013-09-16 14:58:00 -07002813 // User long pressed on empty space
2814 mWorkspace.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS,
2815 HapticFeedbackConstants.FLAG_IGNORE_VIEW_SETTING);
2816 // Disabling reordering until we sort out some issues.
2817 if (mWorkspace.isInOverviewMode()) {
2818 mWorkspace.startReordering(v);
2819 } else {
2820 mWorkspace.enterOverviewMode();
Adam Cohendedbd962013-07-11 14:21:49 -07002821 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002822 } else {
Dan Sandlere26d0942014-01-13 14:30:14 -05002823 final boolean isAllAppsButton = inHotseat && isAllAppsButtonRank(
2824 mHotseat.getOrderInHotseat(
2825 longClickCellInfo.cellX,
2826 longClickCellInfo.cellY));
2827 if (!(itemUnderLongClick instanceof Folder || isAllAppsButton)) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002828 // User long pressed on an item
Michael Jurka0280c3b2010-09-17 15:00:07 -07002829 mWorkspace.startDrag(longClickCellInfo);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002830 }
2831 }
2832 }
2833 return true;
2834 }
2835
Winson Chung3d503fb2011-07-13 17:25:49 -07002836 boolean isHotseatLayout(View layout) {
2837 return mHotseat != null && layout != null &&
2838 (layout instanceof CellLayout) && (layout == mHotseat.getLayout());
2839 }
Romain Guy1fbc1c82009-11-09 20:43:08 -08002840
Winson Chung3d503fb2011-07-13 17:25:49 -07002841 /**
2842 * Returns the CellLayout of the specified container at the specified screen.
2843 */
Adam Cohendcd297f2013-06-18 13:13:40 -07002844 CellLayout getCellLayout(long container, long screenId) {
Winson Chung3d503fb2011-07-13 17:25:49 -07002845 if (container == LauncherSettings.Favorites.CONTAINER_HOTSEAT) {
2846 if (mHotseat != null) {
2847 return mHotseat.getLayout();
2848 } else {
2849 return null;
Romain Guye6b8e2f2009-11-10 11:56:55 -08002850 }
Winson Chung3d503fb2011-07-13 17:25:49 -07002851 } else {
Adam Cohendcd297f2013-06-18 13:13:40 -07002852 return (CellLayout) mWorkspace.getScreenWithId(screenId);
Romain Guya6abce82009-11-10 02:54:41 -08002853 }
2854 }
2855
Daniel Sandler843e8602010-06-07 14:59:01 -04002856 public boolean isAllAppsVisible() {
Winson Chungc93e5ae2012-07-23 20:48:26 -07002857 return (mState == State.APPS_CUSTOMIZE) || (mOnResumeState == State.APPS_CUSTOMIZE);
Joe Onoratofb0ca672009-09-14 17:55:46 -04002858 }
2859
Patrick Dubroy6b509c12010-08-23 15:08:16 -07002860 /**
2861 * Helper method for the cameraZoomIn/cameraZoomOut animations
2862 * @param view The view being animated
Patrick Dubroy6b509c12010-08-23 15:08:16 -07002863 * @param scaleFactor The scale factor used for the zoom
2864 */
Michael Jurkab3e22d92011-10-31 15:58:33 -07002865 private void setPivotsForZoom(View view, float scaleFactor) {
Patrick Dubroy6b509c12010-08-23 15:08:16 -07002866 view.setPivotX(view.getWidth() / 2.0f);
Adam Cohen7777d962011-08-18 18:58:38 -07002867 view.setPivotY(view.getHeight() / 2.0f);
Patrick Dubroy6b509c12010-08-23 15:08:16 -07002868 }
Daniel Sandlerc351eb82010-03-03 15:05:19 -05002869
Craig Mautner360310b2012-10-26 15:13:08 -07002870 private void setWorkspaceBackground(boolean workspace) {
2871 mLauncherView.setBackground(workspace ?
Michael Jurka496fefb2013-05-06 15:39:11 +02002872 mWorkspaceBackgroundDrawable : null);
Craig Mautner360310b2012-10-26 15:13:08 -07002873 }
2874
Selim Cinekf3a8e8c2014-01-16 10:38:38 -08002875 protected void changeWallpaperVisiblity(boolean visible) {
Dianne Hackbornbb003a52011-08-30 14:40:07 -07002876 int wpflags = visible ? WindowManager.LayoutParams.FLAG_SHOW_WALLPAPER : 0;
2877 int curflags = getWindow().getAttributes().flags
2878 & WindowManager.LayoutParams.FLAG_SHOW_WALLPAPER;
2879 if (wpflags != curflags) {
2880 getWindow().setFlags(wpflags, WindowManager.LayoutParams.FLAG_SHOW_WALLPAPER);
2881 }
Craig Mautner360310b2012-10-26 15:13:08 -07002882 setWorkspaceBackground(visible);
Dianne Hackbornbb003a52011-08-30 14:40:07 -07002883 }
2884
Michael Jurkaa35e35a2012-04-26 15:04:28 -07002885 private void dispatchOnLauncherTransitionPrepare(View v, boolean animated, boolean toWorkspace) {
2886 if (v instanceof LauncherTransitionable) {
2887 ((LauncherTransitionable) v).onLauncherTransitionPrepare(this, animated, toWorkspace);
2888 }
2889 }
2890
Michael Jurkabed61d22012-02-14 22:51:29 -08002891 private void dispatchOnLauncherTransitionStart(View v, boolean animated, boolean toWorkspace) {
2892 if (v instanceof LauncherTransitionable) {
2893 ((LauncherTransitionable) v).onLauncherTransitionStart(this, animated, toWorkspace);
2894 }
Winson Chung70442722012-02-10 15:43:22 -08002895
2896 // Update the workspace transition step as well
2897 dispatchOnLauncherTransitionStep(v, 0f);
2898 }
2899
2900 private void dispatchOnLauncherTransitionStep(View v, float t) {
2901 if (v instanceof LauncherTransitionable) {
2902 ((LauncherTransitionable) v).onLauncherTransitionStep(this, t);
2903 }
Michael Jurkabed61d22012-02-14 22:51:29 -08002904 }
2905
2906 private void dispatchOnLauncherTransitionEnd(View v, boolean animated, boolean toWorkspace) {
2907 if (v instanceof LauncherTransitionable) {
2908 ((LauncherTransitionable) v).onLauncherTransitionEnd(this, animated, toWorkspace);
2909 }
Winson Chung70442722012-02-10 15:43:22 -08002910
2911 // Update the workspace transition step as well
2912 dispatchOnLauncherTransitionStep(v, 1f);
Michael Jurkabed61d22012-02-14 22:51:29 -08002913 }
2914
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07002915 /**
Michael Jurkab3e22d92011-10-31 15:58:33 -07002916 * Things to test when changing the following seven functions.
2917 * - Home from workspace
2918 * - from center screen
2919 * - from other screens
2920 * - Home from all apps
2921 * - from center screen
2922 * - from other screens
2923 * - Back from all apps
2924 * - from center screen
2925 * - from other screens
2926 * - Launch app from workspace and quit
2927 * - with back
2928 * - with home
2929 * - Launch app from all apps and quit
2930 * - with back
2931 * - with home
2932 * - Go to a screen that's not the default, then all
2933 * apps, and launch and app, and go back
2934 * - with back
2935 * -with home
2936 * - On workspace, long press power and go back
2937 * - with back
2938 * - with home
2939 * - On all apps, long press power and go back
2940 * - with back
2941 * - with home
2942 * - On workspace, power off
2943 * - On all apps, power off
2944 * - Launch an app and turn off the screen while in that app
2945 * - Go back with home key
2946 * - Go back with back key TODO: make this not go to workspace
2947 * - From all apps
2948 * - From workspace
2949 * - Enter and exit car mode (becuase it causes an extra configuration changed)
2950 * - From all apps
2951 * - From the center workspace
2952 * - From another workspace
2953 */
2954
2955 /**
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07002956 * Zoom the camera out from the workspace to reveal 'toView'.
2957 * Assumes that the view to show is anchored at either the very top or very bottom
2958 * of the screen.
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07002959 */
Michael Jurkabed61d22012-02-14 22:51:29 -08002960 private void showAppsCustomizeHelper(final boolean animated, final boolean springLoaded) {
Winson Chungc58497e2013-09-03 17:48:37 -07002961 AppsCustomizePagedView.ContentType contentType = mAppsCustomizeContent.getContentType();
2962 showAppsCustomizeHelper(animated, springLoaded, contentType);
2963 }
2964 private void showAppsCustomizeHelper(final boolean animated, final boolean springLoaded,
2965 final AppsCustomizePagedView.ContentType contentType) {
Michael Jurkab3e22d92011-10-31 15:58:33 -07002966 if (mStateAnimation != null) {
Michael Jurkaf1ad6082013-03-13 12:55:46 +01002967 mStateAnimation.setDuration(0);
Michael Jurkab3e22d92011-10-31 15:58:33 -07002968 mStateAnimation.cancel();
2969 mStateAnimation = null;
2970 }
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07002971 final Resources res = getResources();
Adam Cohenf16e5712011-01-13 13:31:45 -08002972
Winson Chungf0ea4d32011-06-06 14:27:16 -07002973 final int duration = res.getInteger(R.integer.config_appsCustomizeZoomInTime);
2974 final int fadeDuration = res.getInteger(R.integer.config_appsCustomizeFadeInTime);
2975 final float scale = (float) res.getInteger(R.integer.config_appsCustomizeZoomScaleFactor);
Michael Jurkabed61d22012-02-14 22:51:29 -08002976 final View fromView = mWorkspace;
Michael Jurkaa35e35a2012-04-26 15:04:28 -07002977 final AppsCustomizeTabHost toView = mAppsCustomizeTabHost;
Adam Cohencff6af82011-09-13 14:51:53 -07002978 final int startDelay =
2979 res.getInteger(R.integer.config_workspaceAppsCustomizeAnimationStagger);
Patrick Dubroy558654c2010-07-23 16:48:11 -07002980
Michael Jurkab3e22d92011-10-31 15:58:33 -07002981 setPivotsForZoom(toView, scale);
Patrick Dubroy6b509c12010-08-23 15:08:16 -07002982
Michael Jurkad74c9842011-07-10 12:44:21 -07002983 // Shrink workspaces away if going to AppsCustomize from workspace
Michael Jurka2a4b1a82011-12-07 14:00:02 -08002984 Animator workspaceAnim =
2985 mWorkspace.getChangeStateAnimation(Workspace.State.SMALL, animated);
Nilesh Agrawal16f3ea82014-01-09 17:14:01 -08002986 if (!LauncherAppState.isDisableAllApps()
Nilesh Agrawal306c1cf2013-12-12 14:56:00 -08002987 || contentType == AppsCustomizePagedView.ContentType.Widgets) {
2988 // Set the content type for the all apps/widgets space
Winson Chungc58497e2013-09-03 17:48:37 -07002989 mAppsCustomizeTabHost.setContentTypeImmediate(contentType);
2990 }
Patrick Dubroydf7c3a72010-08-26 17:52:56 -07002991
2992 if (animated) {
Michael Jurka7407d2a2011-12-12 21:48:38 -08002993 toView.setScaleX(scale);
2994 toView.setScaleY(scale);
2995 final LauncherViewPropertyAnimator scaleAnim = new LauncherViewPropertyAnimator(toView);
2996 scaleAnim.
2997 scaleX(1f).scaleY(1f).
2998 setDuration(duration).
2999 setInterpolator(new Workspace.ZoomOutInterpolator());
Adam Cohen61033d32010-11-15 18:29:44 -08003000
Winson Chungf0ea4d32011-06-06 14:27:16 -07003001 toView.setVisibility(View.VISIBLE);
Adam Cohenc00f0b92011-12-06 19:45:06 -08003002 toView.setAlpha(0f);
Michael Jurkaf1ad6082013-03-13 12:55:46 +01003003 final ObjectAnimator alphaAnim = LauncherAnimUtils
Michael Jurka159b4cc2012-01-17 03:00:35 -08003004 .ofFloat(toView, "alpha", 0f, 1f)
3005 .setDuration(fadeDuration);
Winson Chungf0ea4d32011-06-06 14:27:16 -07003006 alphaAnim.setInterpolator(new DecelerateInterpolator(1.5f));
Winson Chung70442722012-02-10 15:43:22 -08003007 alphaAnim.addUpdateListener(new AnimatorUpdateListener() {
3008 @Override
3009 public void onAnimationUpdate(ValueAnimator animation) {
Michael Jurka059798a2012-09-04 09:20:16 -07003010 if (animation == null) {
3011 throw new RuntimeException("animation is null");
3012 }
Winson Chung70442722012-02-10 15:43:22 -08003013 float t = (Float) animation.getAnimatedValue();
3014 dispatchOnLauncherTransitionStep(fromView, t);
3015 dispatchOnLauncherTransitionStep(toView, t);
3016 }
3017 });
Adam Cohenf16e5712011-01-13 13:31:45 -08003018
Michael Jurka2a4b1a82011-12-07 14:00:02 -08003019 // toView should appear right at the end of the workspace shrink
3020 // animation
Michael Jurka2ecf9952012-06-18 12:52:28 -07003021 mStateAnimation = LauncherAnimUtils.createAnimatorSet();
Michael Jurka2a4b1a82011-12-07 14:00:02 -08003022 mStateAnimation.play(scaleAnim).after(startDelay);
Michael Jurka7407d2a2011-12-12 21:48:38 -08003023 mStateAnimation.play(alphaAnim).after(startDelay);
Michael Jurka2a4b1a82011-12-07 14:00:02 -08003024
3025 mStateAnimation.addListener(new AnimatorListenerAdapter() {
Gilles Debunnedd6c9922010-10-25 11:23:41 -07003026 @Override
Chet Haaseb1254a62010-09-07 13:35:00 -07003027 public void onAnimationStart(Animator animation) {
Patrick Dubroydf7c3a72010-08-26 17:52:56 -07003028 // Prepare the position
3029 toView.setTranslationX(0.0f);
3030 toView.setTranslationY(0.0f);
3031 toView.setVisibility(View.VISIBLE);
Winson Chung785d2eb2011-04-14 16:08:02 -07003032 toView.bringToFront();
Patrick Dubroydf7c3a72010-08-26 17:52:56 -07003033 }
Michael Jurka3c4c20f2010-10-28 15:36:06 -07003034 @Override
Michael Jurka8edd75c2010-12-17 20:15:06 -08003035 public void onAnimationEnd(Animator animation) {
Michael Jurkabed61d22012-02-14 22:51:29 -08003036 dispatchOnLauncherTransitionEnd(fromView, animated, false);
3037 dispatchOnLauncherTransitionEnd(toView, animated, false);
Winson Chung32174c82011-07-19 15:47:55 -07003038
Winson Chungc7d2b602012-05-16 17:02:20 -07003039 // Hide the search bar
Winson Chungadf0c182012-08-23 14:59:07 -07003040 if (mSearchDropTargetBar != null) {
3041 mSearchDropTargetBar.hideSearchBar(false);
3042 }
Adam Cohenf4ddea32011-09-12 13:46:42 -07003043 }
Patrick Dubroydf7c3a72010-08-26 17:52:56 -07003044 });
3045
Michael Jurka2a4b1a82011-12-07 14:00:02 -08003046 if (workspaceAnim != null) {
3047 mStateAnimation.play(workspaceAnim);
3048 }
Michael Jurka1899a362011-11-03 13:50:45 -07003049
3050 boolean delayAnim = false;
Michael Jurka2a4b1a82011-12-07 14:00:02 -08003051
Michael Jurkaa35e35a2012-04-26 15:04:28 -07003052 dispatchOnLauncherTransitionPrepare(fromView, animated, false);
3053 dispatchOnLauncherTransitionPrepare(toView, animated, false);
Michael Jurka2a4b1a82011-12-07 14:00:02 -08003054
3055 // If any of the objects being animated haven't been measured/laid out
3056 // yet, delay the animation until we get a layout pass
Michael Jurkabed61d22012-02-14 22:51:29 -08003057 if ((((LauncherTransitionable) toView).getContent().getMeasuredWidth() == 0) ||
Michael Jurka2a4b1a82011-12-07 14:00:02 -08003058 (mWorkspace.getMeasuredWidth() == 0) ||
3059 (toView.getMeasuredWidth() == 0)) {
Michael Jurka2a4b1a82011-12-07 14:00:02 -08003060 delayAnim = true;
Michael Jurka1899a362011-11-03 13:50:45 -07003061 }
Michael Jurka2a4b1a82011-12-07 14:00:02 -08003062
Michael Jurka3dcd79e2012-05-31 07:50:33 -07003063 final AnimatorSet stateAnimation = mStateAnimation;
3064 final Runnable startAnimRunnable = new Runnable() {
3065 public void run() {
3066 // Check that mStateAnimation hasn't changed while
3067 // we waited for a layout/draw pass
3068 if (mStateAnimation != stateAnimation)
3069 return;
3070 setPivotsForZoom(toView, scale);
3071 dispatchOnLauncherTransitionStart(fromView, animated, false);
3072 dispatchOnLauncherTransitionStart(toView, animated, false);
Michael Jurkaf1ad6082013-03-13 12:55:46 +01003073 LauncherAnimUtils.startAnimationAfterNextDraw(mStateAnimation, toView);
Michael Jurka3dcd79e2012-05-31 07:50:33 -07003074 }
3075 };
Michael Jurka2a4b1a82011-12-07 14:00:02 -08003076 if (delayAnim) {
Michael Jurkaf1ad6082013-03-13 12:55:46 +01003077 final ViewTreeObserver observer = toView.getViewTreeObserver();
3078 observer.addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
3079 public void onGlobalLayout() {
3080 startAnimRunnable.run();
3081 toView.getViewTreeObserver().removeOnGlobalLayoutListener(this);
3082 }
3083 });
Michael Jurka2a4b1a82011-12-07 14:00:02 -08003084 } else {
Michael Jurka3dcd79e2012-05-31 07:50:33 -07003085 startAnimRunnable.run();
Michael Jurka1899a362011-11-03 13:50:45 -07003086 }
Patrick Dubroydf7c3a72010-08-26 17:52:56 -07003087 } else {
3088 toView.setTranslationX(0.0f);
3089 toView.setTranslationY(0.0f);
3090 toView.setScaleX(1.0f);
3091 toView.setScaleY(1.0f);
3092 toView.setVisibility(View.VISIBLE);
Winson Chung785d2eb2011-04-14 16:08:02 -07003093 toView.bringToFront();
Winson Chung3ac74c52011-06-30 17:39:37 -07003094
Daniel Sandlere4f98912013-06-25 15:13:26 -04003095 if (!springLoaded && !LauncherAppState.getInstance().isScreenLarge()) {
Winson Chungc7d2b602012-05-16 17:02:20 -07003096 // Hide the search bar
Winson Chungadf0c182012-08-23 14:59:07 -07003097 if (mSearchDropTargetBar != null) {
3098 mSearchDropTargetBar.hideSearchBar(false);
3099 }
Michael Jurkaabded662011-03-04 12:06:57 -08003100 }
Michael Jurkaa35e35a2012-04-26 15:04:28 -07003101 dispatchOnLauncherTransitionPrepare(fromView, animated, false);
Michael Jurkabed61d22012-02-14 22:51:29 -08003102 dispatchOnLauncherTransitionStart(fromView, animated, false);
3103 dispatchOnLauncherTransitionEnd(fromView, animated, false);
Michael Jurkaa35e35a2012-04-26 15:04:28 -07003104 dispatchOnLauncherTransitionPrepare(toView, animated, false);
Michael Jurkabed61d22012-02-14 22:51:29 -08003105 dispatchOnLauncherTransitionStart(toView, animated, false);
3106 dispatchOnLauncherTransitionEnd(toView, animated, false);
Patrick Dubroydf7c3a72010-08-26 17:52:56 -07003107 }
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07003108 }
3109
3110 /**
3111 * Zoom the camera back into the workspace, hiding 'fromView'.
Michael Jurkab3e22d92011-10-31 15:58:33 -07003112 * This is the opposite of showAppsCustomizeHelper.
Patrick Dubroy6b509c12010-08-23 15:08:16 -07003113 * @param animated If true, the transition will be animated.
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07003114 */
Adam Cohened307df2013-10-02 09:37:31 -07003115 private void hideAppsCustomizeHelper(Workspace.State toState, final boolean animated,
Adam Cohened66b2b2012-01-23 17:28:51 -08003116 final boolean springLoaded, final Runnable onCompleteRunnable) {
Michael Jurkabed61d22012-02-14 22:51:29 -08003117
Michael Jurkab3e22d92011-10-31 15:58:33 -07003118 if (mStateAnimation != null) {
Michael Jurkaf1ad6082013-03-13 12:55:46 +01003119 mStateAnimation.setDuration(0);
Michael Jurkab3e22d92011-10-31 15:58:33 -07003120 mStateAnimation.cancel();
3121 mStateAnimation = null;
3122 }
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07003123 Resources res = getResources();
Adam Cohenf16e5712011-01-13 13:31:45 -08003124
Winson Chungf0ea4d32011-06-06 14:27:16 -07003125 final int duration = res.getInteger(R.integer.config_appsCustomizeZoomOutTime);
Michael Jurka159b4cc2012-01-17 03:00:35 -08003126 final int fadeOutDuration =
3127 res.getInteger(R.integer.config_appsCustomizeFadeOutTime);
Winson Chungf0ea4d32011-06-06 14:27:16 -07003128 final float scaleFactor = (float)
3129 res.getInteger(R.integer.config_appsCustomizeZoomScaleFactor);
3130 final View fromView = mAppsCustomizeTabHost;
Michael Jurkabed61d22012-02-14 22:51:29 -08003131 final View toView = mWorkspace;
Michael Jurka2a4b1a82011-12-07 14:00:02 -08003132 Animator workspaceAnim = null;
Adam Cohened307df2013-10-02 09:37:31 -07003133 if (toState == Workspace.State.NORMAL) {
Michael Jurka2a4b1a82011-12-07 14:00:02 -08003134 int stagger = res.getInteger(R.integer.config_appsCustomizeWorkspaceAnimationStagger);
3135 workspaceAnim = mWorkspace.getChangeStateAnimation(
Adam Cohened307df2013-10-02 09:37:31 -07003136 toState, animated, stagger, -1);
3137 } else if (toState == Workspace.State.SPRING_LOADED ||
3138 toState == Workspace.State.OVERVIEW) {
Michael Jurka2a4b1a82011-12-07 14:00:02 -08003139 workspaceAnim = mWorkspace.getChangeStateAnimation(
Adam Cohened307df2013-10-02 09:37:31 -07003140 toState, animated);
Michael Jurka2a4b1a82011-12-07 14:00:02 -08003141 }
Patrick Dubroy2b9ff372010-09-07 17:49:27 -07003142
Michael Jurkab3e22d92011-10-31 15:58:33 -07003143 setPivotsForZoom(fromView, scaleFactor);
Winson Chung4afe9b32011-07-27 17:46:20 -07003144 showHotseat(animated);
Patrick Dubroydf7c3a72010-08-26 17:52:56 -07003145 if (animated) {
Michael Jurka159b4cc2012-01-17 03:00:35 -08003146 final LauncherViewPropertyAnimator scaleAnim =
3147 new LauncherViewPropertyAnimator(fromView);
3148 scaleAnim.
3149 scaleX(scaleFactor).scaleY(scaleFactor).
3150 setDuration(duration).
3151 setInterpolator(new Workspace.ZoomInInterpolator());
3152
Michael Jurkaf1ad6082013-03-13 12:55:46 +01003153 final ObjectAnimator alphaAnim = LauncherAnimUtils
Michael Jurka159b4cc2012-01-17 03:00:35 -08003154 .ofFloat(fromView, "alpha", 1f, 0f)
3155 .setDuration(fadeOutDuration);
Adam Cohencff6af82011-09-13 14:51:53 -07003156 alphaAnim.setInterpolator(new AccelerateDecelerateInterpolator());
Winson Chung70442722012-02-10 15:43:22 -08003157 alphaAnim.addUpdateListener(new AnimatorUpdateListener() {
3158 @Override
3159 public void onAnimationUpdate(ValueAnimator animation) {
3160 float t = 1f - (Float) animation.getAnimatedValue();
3161 dispatchOnLauncherTransitionStep(fromView, t);
3162 dispatchOnLauncherTransitionStep(toView, t);
3163 }
3164 });
Michael Jurka159b4cc2012-01-17 03:00:35 -08003165
Michael Jurka2ecf9952012-06-18 12:52:28 -07003166 mStateAnimation = LauncherAnimUtils.createAnimatorSet();
Michael Jurkabed61d22012-02-14 22:51:29 -08003167
Michael Jurkaa35e35a2012-04-26 15:04:28 -07003168 dispatchOnLauncherTransitionPrepare(fromView, animated, true);
3169 dispatchOnLauncherTransitionPrepare(toView, animated, true);
Adam Cohen4fe4c932013-10-28 16:02:34 -07003170 mAppsCustomizeContent.stopScrolling();
Michael Jurkabed61d22012-02-14 22:51:29 -08003171
3172 mStateAnimation.addListener(new AnimatorListenerAdapter() {
Gilles Debunnedd6c9922010-10-25 11:23:41 -07003173 @Override
Michael Jurka8edd75c2010-12-17 20:15:06 -08003174 public void onAnimationEnd(Animator animation) {
Patrick Dubroydf7c3a72010-08-26 17:52:56 -07003175 fromView.setVisibility(View.GONE);
Michael Jurkabed61d22012-02-14 22:51:29 -08003176 dispatchOnLauncherTransitionEnd(fromView, animated, true);
3177 dispatchOnLauncherTransitionEnd(toView, animated, true);
Adam Cohened66b2b2012-01-23 17:28:51 -08003178 if (onCompleteRunnable != null) {
3179 onCompleteRunnable.run();
3180 }
Chet Haasebc2f0822012-10-26 17:59:53 -07003181 mAppsCustomizeContent.updateCurrentPageScroll();
Patrick Dubroydf7c3a72010-08-26 17:52:56 -07003182 }
3183 });
3184
Winson Chungf0ea4d32011-06-06 14:27:16 -07003185 mStateAnimation.playTogether(scaleAnim, alphaAnim);
Michael Jurka2a4b1a82011-12-07 14:00:02 -08003186 if (workspaceAnim != null) {
3187 mStateAnimation.play(workspaceAnim);
3188 }
Michael Jurkaa35e35a2012-04-26 15:04:28 -07003189 dispatchOnLauncherTransitionStart(fromView, animated, true);
3190 dispatchOnLauncherTransitionStart(toView, animated, true);
Michael Jurkaf1ad6082013-03-13 12:55:46 +01003191 LauncherAnimUtils.startAnimationAfterNextDraw(mStateAnimation, toView);
Patrick Dubroydf7c3a72010-08-26 17:52:56 -07003192 } else {
3193 fromView.setVisibility(View.GONE);
Michael Jurkaa35e35a2012-04-26 15:04:28 -07003194 dispatchOnLauncherTransitionPrepare(fromView, animated, true);
Michael Jurkabed61d22012-02-14 22:51:29 -08003195 dispatchOnLauncherTransitionStart(fromView, animated, true);
3196 dispatchOnLauncherTransitionEnd(fromView, animated, true);
Michael Jurkaa35e35a2012-04-26 15:04:28 -07003197 dispatchOnLauncherTransitionPrepare(toView, animated, true);
Michael Jurkabed61d22012-02-14 22:51:29 -08003198 dispatchOnLauncherTransitionStart(toView, animated, true);
3199 dispatchOnLauncherTransitionEnd(toView, animated, true);
Patrick Dubroydf7c3a72010-08-26 17:52:56 -07003200 }
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07003201 }
3202
Michael Jurkae326f182011-11-21 14:05:46 -08003203 @Override
3204 public void onTrimMemory(int level) {
3205 super.onTrimMemory(level);
Winson Chungc7450e32012-04-17 17:34:08 -07003206 if (level >= ComponentCallbacks2.TRIM_MEMORY_MODERATE) {
Michael Jurkae326f182011-11-21 14:05:46 -08003207 mAppsCustomizeTabHost.onTrimMemory();
3208 }
3209 }
3210
Adam Cohened307df2013-10-02 09:37:31 -07003211 protected void showWorkspace(boolean animated) {
Adam Cohened66b2b2012-01-23 17:28:51 -08003212 showWorkspace(animated, null);
3213 }
3214
Adam Cohened307df2013-10-02 09:37:31 -07003215 protected void showWorkspace() {
3216 showWorkspace(true);
3217 }
3218
Adam Cohened66b2b2012-01-23 17:28:51 -08003219 void showWorkspace(boolean animated, Runnable onCompleteRunnable) {
Adam Cohened307df2013-10-02 09:37:31 -07003220 if (mWorkspace.isInOverviewMode()) {
3221 mWorkspace.exitOverviewMode(animated);
3222 }
Michael Jurkab3e22d92011-10-31 15:58:33 -07003223 if (mState != State.WORKSPACE) {
Winson Chung2d75f122013-09-23 16:53:31 -07003224 boolean wasInSpringLoadedMode = (mState != State.WORKSPACE);
Michael Jurkab3e22d92011-10-31 15:58:33 -07003225 mWorkspace.setVisibility(View.VISIBLE);
Adam Cohened307df2013-10-02 09:37:31 -07003226 hideAppsCustomizeHelper(Workspace.State.NORMAL, animated, false, onCompleteRunnable);
Michael Jurkab3e22d92011-10-31 15:58:33 -07003227
Winson Chungc7d2b602012-05-16 17:02:20 -07003228 // Show the search bar (only animate if we were showing the drop target bar in spring
3229 // loaded mode)
Winson Chungadf0c182012-08-23 14:59:07 -07003230 if (mSearchDropTargetBar != null) {
Winson Chung04c0a5c2013-10-08 17:13:12 -07003231 mSearchDropTargetBar.showSearchBar(animated && wasInSpringLoadedMode);
Winson Chungadf0c182012-08-23 14:59:07 -07003232 }
Winson Chungc7d2b602012-05-16 17:02:20 -07003233
Michael Jurkab3e22d92011-10-31 15:58:33 -07003234 // Set focus to the AppsCustomize button
3235 if (mAllAppsButton != null) {
3236 mAllAppsButton.requestFocus();
3237 }
Michael Jurkac0e8fca2010-10-06 16:41:29 -07003238 }
Adam Lesinski6b879f02010-11-04 16:15:23 -07003239
Michael Jurkac0e8fca2010-10-06 16:41:29 -07003240 // Change the state *after* we've called all the transition code
3241 mState = State.WORKSPACE;
Svetoslav Ganov815ba2d2011-01-07 14:55:17 -08003242
Winson Chung5fb63472011-02-02 17:03:37 -08003243 // Resume the auto-advance of widgets
3244 mUserPresent = true;
3245 updateRunning();
3246
alanv1d4fde62012-10-17 13:15:47 -07003247 // Send an accessibility event to announce the context change
3248 getWindow().getDecorView()
3249 .sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
Bjorn Bringertc459e522013-06-07 19:36:01 +01003250
Bjorn Bringert69688aa2013-06-11 20:26:38 +01003251 onWorkspaceShown(animated);
Bjorn Bringertc459e522013-06-07 19:36:01 +01003252 }
3253
Adam Cohened307df2013-10-02 09:37:31 -07003254 void showOverviewMode(boolean animated) {
3255 mWorkspace.setVisibility(View.VISIBLE);
3256 hideAppsCustomizeHelper(Workspace.State.OVERVIEW, animated, false, null);
3257 mState = State.WORKSPACE;
3258 onWorkspaceShown(animated);
3259 }
3260
Bjorn Bringert69688aa2013-06-11 20:26:38 +01003261 public void onWorkspaceShown(boolean animated) {
Joe Onorato00acb122009-08-04 16:04:30 -04003262 }
3263
Winson Chung82963d52013-10-09 11:20:57 -07003264 void showAllApps(boolean animated, AppsCustomizePagedView.ContentType contentType,
3265 boolean resetPageToZero) {
Michael Jurkab3e22d92011-10-31 15:58:33 -07003266 if (mState != State.WORKSPACE) return;
3267
Winson Chung82963d52013-10-09 11:20:57 -07003268 if (resetPageToZero) {
3269 mAppsCustomizeTabHost.reset();
3270 }
Winson Chungc58497e2013-09-03 17:48:37 -07003271 showAppsCustomizeHelper(animated, false, contentType);
Michael Jurkab3e22d92011-10-31 15:58:33 -07003272 mAppsCustomizeTabHost.requestFocus();
3273
Michael Jurkab3e22d92011-10-31 15:58:33 -07003274 // Change the state *after* we've called all the transition code
3275 mState = State.APPS_CUSTOMIZE;
3276
3277 // Pause the auto-advance of widgets until we are out of AllApps
3278 mUserPresent = false;
3279 updateRunning();
3280 closeFolder();
3281
3282 // Send an accessibility event to announce the context change
alanv1d4fde62012-10-17 13:15:47 -07003283 getWindow().getDecorView()
3284 .sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
Michael Jurkab3e22d92011-10-31 15:58:33 -07003285 }
3286
Adam Cohen7777d962011-08-18 18:58:38 -07003287 void enterSpringLoadedDragMode() {
Winson Chungc93e5ae2012-07-23 20:48:26 -07003288 if (isAllAppsVisible()) {
Adam Cohened307df2013-10-02 09:37:31 -07003289 hideAppsCustomizeHelper(Workspace.State.SPRING_LOADED, true, true, null);
Winson Chungc07918d2011-07-01 15:35:26 -07003290 mState = State.APPS_CUSTOMIZE_SPRING_LOADED;
Winson Chungb26f3d62011-06-02 10:49:29 -07003291 }
Michael Jurkad3ef3062010-11-23 16:23:58 -08003292 }
Adam Cohen7777d962011-08-18 18:58:38 -07003293
Adam Cohenad4e15c2013-10-17 16:21:35 -07003294 void exitSpringLoadedDragModeDelayed(final boolean successfulDrop, int delay,
Adam Cohened66b2b2012-01-23 17:28:51 -08003295 final Runnable onCompleteRunnable) {
Winson Chung09bfc452011-09-09 11:30:20 -07003296 if (mState != State.APPS_CUSTOMIZE_SPRING_LOADED) return;
3297
Winson Chunge7a03942011-08-05 15:05:12 -07003298 mHandler.postDelayed(new Runnable() {
Winson Chung557d6ed2011-07-08 15:34:52 -07003299 @Override
3300 public void run() {
Winson Chung6a3fd3f2011-08-02 14:03:26 -07003301 if (successfulDrop) {
Michael Jurka7bdb25a2011-08-03 15:16:44 -07003302 // Before we show workspace, hide all apps again because
3303 // exitSpringLoadedDragMode made it visible. This is a bit hacky; we should
3304 // clean up our state transition functions
3305 mAppsCustomizeTabHost.setVisibility(View.GONE);
Adam Cohened66b2b2012-01-23 17:28:51 -08003306 showWorkspace(true, onCompleteRunnable);
Adam Cohen7777d962011-08-18 18:58:38 -07003307 } else {
3308 exitSpringLoadedDragMode();
Winson Chung6a3fd3f2011-08-02 14:03:26 -07003309 }
Winson Chung557d6ed2011-07-08 15:34:52 -07003310 }
Adam Cohenad4e15c2013-10-17 16:21:35 -07003311 }, delay);
3312
Winson Chung557d6ed2011-07-08 15:34:52 -07003313 }
Michael Jurkab3e22d92011-10-31 15:58:33 -07003314
Michael Jurkad3ef3062010-11-23 16:23:58 -08003315 void exitSpringLoadedDragMode() {
Winson Chungb26f3d62011-06-02 10:49:29 -07003316 if (mState == State.APPS_CUSTOMIZE_SPRING_LOADED) {
Michael Jurkab3e22d92011-10-31 15:58:33 -07003317 final boolean animated = true;
3318 final boolean springLoaded = true;
3319 showAppsCustomizeHelper(animated, springLoaded);
Winson Chungb26f3d62011-06-02 10:49:29 -07003320 mState = State.APPS_CUSTOMIZE;
Winson Chungf0ea4d32011-06-06 14:27:16 -07003321 }
3322 // Otherwise, we are not in spring loaded mode, so don't do anything.
3323 }
3324
Michael Jurkab3e22d92011-10-31 15:58:33 -07003325 void lockAllApps() {
3326 // TODO
3327 }
3328
3329 void unlockAllApps() {
3330 // TODO
3331 }
3332
Winson Chungf0ea4d32011-06-06 14:27:16 -07003333 /**
Winson Chung3d503fb2011-07-13 17:25:49 -07003334 * Shows the hotseat area.
Winson Chungf0ea4d32011-06-06 14:27:16 -07003335 */
Winson Chung3d503fb2011-07-13 17:25:49 -07003336 void showHotseat(boolean animated) {
Daniel Sandlere4f98912013-06-25 15:13:26 -04003337 if (!LauncherAppState.getInstance().isScreenLarge()) {
Winson Chungf0ea4d32011-06-06 14:27:16 -07003338 if (animated) {
Michael Jurka7407d2a2011-12-12 21:48:38 -08003339 if (mHotseat.getAlpha() != 1f) {
Winson Chungadf0c182012-08-23 14:59:07 -07003340 int duration = 0;
3341 if (mSearchDropTargetBar != null) {
3342 duration = mSearchDropTargetBar.getTransitionInDuration();
3343 }
Michael Jurka7407d2a2011-12-12 21:48:38 -08003344 mHotseat.animate().alpha(1f).setDuration(duration);
3345 }
Winson Chungf0ea4d32011-06-06 14:27:16 -07003346 } else {
Winson Chung3d503fb2011-07-13 17:25:49 -07003347 mHotseat.setAlpha(1f);
Winson Chungf0ea4d32011-06-06 14:27:16 -07003348 }
3349 }
3350 }
3351
3352 /**
Winson Chung3d503fb2011-07-13 17:25:49 -07003353 * Hides the hotseat area.
Winson Chungf0ea4d32011-06-06 14:27:16 -07003354 */
Winson Chung3d503fb2011-07-13 17:25:49 -07003355 void hideHotseat(boolean animated) {
Daniel Sandlere4f98912013-06-25 15:13:26 -04003356 if (!LauncherAppState.getInstance().isScreenLarge()) {
Winson Chungf0ea4d32011-06-06 14:27:16 -07003357 if (animated) {
Michael Jurka7407d2a2011-12-12 21:48:38 -08003358 if (mHotseat.getAlpha() != 0f) {
Winson Chungadf0c182012-08-23 14:59:07 -07003359 int duration = 0;
3360 if (mSearchDropTargetBar != null) {
3361 duration = mSearchDropTargetBar.getTransitionOutDuration();
3362 }
Michael Jurka7407d2a2011-12-12 21:48:38 -08003363 mHotseat.animate().alpha(0f).setDuration(duration);
3364 }
Winson Chungf0ea4d32011-06-06 14:27:16 -07003365 } else {
Winson Chung3d503fb2011-07-13 17:25:49 -07003366 mHotseat.setAlpha(0f);
Winson Chungf0ea4d32011-06-06 14:27:16 -07003367 }
Winson Chungb26f3d62011-06-02 10:49:29 -07003368 }
Michael Jurkad3ef3062010-11-23 16:23:58 -08003369 }
3370
Patrick Dubroy5f445422011-02-18 14:35:21 -08003371 /**
3372 * Add an item from all apps or customize onto the given workspace screen.
3373 * If layout is null, add to the current screen.
3374 */
3375 void addExternalItemToScreen(ItemInfo itemInfo, final CellLayout layout) {
Michael Jurka6b4b25d2010-10-20 18:19:45 -07003376 if (!mWorkspace.addExternalItemToScreen(itemInfo, layout)) {
Winson Chung93eef082012-03-23 15:59:27 -07003377 showOutOfSpaceMessage(isHotseatLayout(layout));
Michael Jurka213d9632010-07-28 11:29:25 -07003378 }
Michael Jurka6b4b25d2010-10-20 18:19:45 -07003379 }
Patrick Dubroy2b9ff372010-09-07 17:49:27 -07003380
Winson Chungdff8ebb2011-09-08 17:25:31 -07003381 /** Maps the current orientation to an index for referencing orientation correct global icons */
3382 private int getCurrentOrientationIndexForGlobalIcons() {
3383 // default - 0, landscape - 1
3384 switch (getResources().getConfiguration().orientation) {
3385 case Configuration.ORIENTATION_LANDSCAPE:
3386 return 1;
3387 default:
3388 return 0;
3389 }
3390 }
3391
Michael Jurkaae65ee32012-04-30 11:45:54 -07003392 private Drawable getExternalPackageToolbarIcon(ComponentName activityName, String resourceName) {
Michael Jurka0423dcf2010-10-05 14:56:18 -07003393 try {
Patrick Dubroyceae05d2010-08-30 10:40:53 -07003394 PackageManager packageManager = getPackageManager();
Michael Jurka0423dcf2010-10-05 14:56:18 -07003395 // Look for the toolbar icon specified in the activity meta-data
3396 Bundle metaData = packageManager.getActivityInfo(
3397 activityName, PackageManager.GET_META_DATA).metaData;
3398 if (metaData != null) {
Michael Jurkaae65ee32012-04-30 11:45:54 -07003399 int iconResId = metaData.getInt(resourceName);
Michael Jurka0423dcf2010-10-05 14:56:18 -07003400 if (iconResId != 0) {
3401 Resources res = packageManager.getResourcesForActivity(activityName);
Winson Chungfbb3d9b2011-03-01 12:43:02 -08003402 return res.getDrawable(iconResId);
Michael Jurka0423dcf2010-10-05 14:56:18 -07003403 }
3404 }
3405 } catch (NameNotFoundException e) {
Michael Jurkab6052a92011-07-12 17:02:45 -07003406 // This can happen if the activity defines an invalid drawable
3407 Log.w(TAG, "Failed to load toolbar icon; " + activityName.flattenToShortString() +
3408 " not found", e);
Mathew Inwood70d51022011-07-12 13:41:41 +01003409 } catch (Resources.NotFoundException nfe) {
3410 // This can happen if the activity defines an invalid drawable
3411 Log.w(TAG, "Failed to load toolbar icon from " + activityName.flattenToShortString(),
3412 nfe);
Michael Jurka0423dcf2010-10-05 14:56:18 -07003413 }
Winson Chungfbb3d9b2011-03-01 12:43:02 -08003414 return null;
3415 }
3416
3417 // if successful in getting icon, return it; otherwise, set button to use default drawable
3418 private Drawable.ConstantState updateTextButtonWithIconFromExternalActivity(
Michael Jurkaae65ee32012-04-30 11:45:54 -07003419 int buttonId, ComponentName activityName, int fallbackDrawableId,
3420 String toolbarResourceName) {
3421 Drawable toolbarIcon = getExternalPackageToolbarIcon(activityName, toolbarResourceName);
Winson Chung128bbcd2011-08-31 16:58:52 -07003422 Resources r = getResources();
3423 int w = r.getDimensionPixelSize(R.dimen.toolbar_external_icon_width);
3424 int h = r.getDimensionPixelSize(R.dimen.toolbar_external_icon_height);
Winson Chungfbb3d9b2011-03-01 12:43:02 -08003425
Michael Jurka4da7a3e2011-10-28 15:04:35 -07003426 TextView button = (TextView) findViewById(buttonId);
Winson Chungfbb3d9b2011-03-01 12:43:02 -08003427 // If we were unable to find the icon via the meta-data, use a generic one
3428 if (toolbarIcon == null) {
Winson Chung128bbcd2011-08-31 16:58:52 -07003429 toolbarIcon = r.getDrawable(fallbackDrawableId);
3430 toolbarIcon.setBounds(0, 0, w, h);
Michael Jurka4da7a3e2011-10-28 15:04:35 -07003431 if (button != null) {
3432 button.setCompoundDrawables(toolbarIcon, null, null, null);
3433 }
Winson Chungfbb3d9b2011-03-01 12:43:02 -08003434 return null;
3435 } else {
Winson Chung128bbcd2011-08-31 16:58:52 -07003436 toolbarIcon.setBounds(0, 0, w, h);
Michael Jurka4da7a3e2011-10-28 15:04:35 -07003437 if (button != null) {
3438 button.setCompoundDrawables(toolbarIcon, null, null, null);
3439 }
Winson Chungfbb3d9b2011-03-01 12:43:02 -08003440 return toolbarIcon.getConstantState();
3441 }
3442 }
3443
3444 // if successful in getting icon, return it; otherwise, set button to use default drawable
3445 private Drawable.ConstantState updateButtonWithIconFromExternalActivity(
Michael Jurkaae65ee32012-04-30 11:45:54 -07003446 int buttonId, ComponentName activityName, int fallbackDrawableId,
3447 String toolbarResourceName) {
Winson Chungfbb3d9b2011-03-01 12:43:02 -08003448 ImageView button = (ImageView) findViewById(buttonId);
Michael Jurkaae65ee32012-04-30 11:45:54 -07003449 Drawable toolbarIcon = getExternalPackageToolbarIcon(activityName, toolbarResourceName);
Winson Chungfbb3d9b2011-03-01 12:43:02 -08003450
Michael Jurka19e0fc52011-07-22 18:00:21 -07003451 if (button != null) {
3452 // If we were unable to find the icon via the meta-data, use a
3453 // generic one
3454 if (toolbarIcon == null) {
3455 button.setImageResource(fallbackDrawableId);
3456 } else {
3457 button.setImageDrawable(toolbarIcon);
3458 }
Michael Jurka0423dcf2010-10-05 14:56:18 -07003459 }
Michael Jurka19e0fc52011-07-22 18:00:21 -07003460
3461 return toolbarIcon != null ? toolbarIcon.getConstantState() : null;
3462
Michael Jurka0423dcf2010-10-05 14:56:18 -07003463 }
3464
Winson Chung1b884092012-06-08 17:13:02 -07003465 private void updateTextButtonWithDrawable(int buttonId, Drawable d) {
Winson Chungfbb3d9b2011-03-01 12:43:02 -08003466 TextView button = (TextView) findViewById(buttonId);
Winson Chung1b884092012-06-08 17:13:02 -07003467 button.setCompoundDrawables(d, null, null, null);
Winson Chungfbb3d9b2011-03-01 12:43:02 -08003468 }
3469
Michael Jurkae7bf83b2010-12-14 18:02:21 -08003470 private void updateButtonWithDrawable(int buttonId, Drawable.ConstantState d) {
Michael Jurka4ef207b2010-11-29 17:05:45 -08003471 ImageView button = (ImageView) findViewById(buttonId);
Michael Jurkae7bf83b2010-12-14 18:02:21 -08003472 button.setImageDrawable(d.newDrawable(getResources()));
Michael Jurka4ef207b2010-11-29 17:05:45 -08003473 }
3474
Winson Chungbb185bd2011-11-21 12:31:42 -08003475 private void invalidatePressedFocusedStates(View container, View button) {
3476 if (container instanceof HolographicLinearLayout) {
3477 HolographicLinearLayout layout = (HolographicLinearLayout) container;
3478 layout.invalidatePressedFocusedStates();
3479 } else if (button instanceof HolographicImageView) {
3480 HolographicImageView view = (HolographicImageView) button;
3481 view.invalidatePressedFocusedStates();
3482 }
3483 }
3484
Cristina Stancu476493b2013-08-07 17:20:14 +01003485 public View getQsbBar() {
Adam Cohen24ce0b32014-01-14 16:18:14 -08003486 if (mQsb == null) {
3487 mQsb = mInflater.inflate(R.layout.qsb, mSearchDropTargetBar, false);
3488 mSearchDropTargetBar.addView(mQsb);
Cristina Stancu476493b2013-08-07 17:20:14 +01003489 }
Adam Cohen24ce0b32014-01-14 16:18:14 -08003490 return mQsb;
Cristina Stancu476493b2013-08-07 17:20:14 +01003491 }
3492
3493 protected boolean updateGlobalSearchIcon() {
Winson Chungc51db6a2011-10-05 11:44:49 -07003494 final View searchButtonContainer = findViewById(R.id.search_button_container);
Winson Chung1cad91e2011-05-25 17:41:01 -07003495 final ImageView searchButton = (ImageView) findViewById(R.id.search_button);
Winson Chungc51db6a2011-10-05 11:44:49 -07003496 final View voiceButtonContainer = findViewById(R.id.voice_button_container);
Winson Chungcbf7c4d2011-08-23 11:58:54 -07003497 final View voiceButton = findViewById(R.id.voice_button);
Winson Chung97d85d22011-04-13 11:27:36 -07003498
Winson Chung1cad91e2011-05-25 17:41:01 -07003499 final SearchManager searchManager =
3500 (SearchManager) getSystemService(Context.SEARCH_SERVICE);
3501 ComponentName activityName = searchManager.getGlobalSearchActivity();
3502 if (activityName != null) {
Winson Chungdff8ebb2011-09-08 17:25:31 -07003503 int coi = getCurrentOrientationIndexForGlobalIcons();
3504 sGlobalSearchIcon[coi] = updateButtonWithIconFromExternalActivity(
Michael Jurkaae65ee32012-04-30 11:45:54 -07003505 R.id.search_button, activityName, R.drawable.ic_home_search_normal_holo,
3506 TOOLBAR_SEARCH_ICON_METADATA_NAME);
3507 if (sGlobalSearchIcon[coi] == null) {
3508 sGlobalSearchIcon[coi] = updateButtonWithIconFromExternalActivity(
3509 R.id.search_button, activityName, R.drawable.ic_home_search_normal_holo,
3510 TOOLBAR_ICON_METADATA_NAME);
3511 }
3512
Winson Chungc51db6a2011-10-05 11:44:49 -07003513 if (searchButtonContainer != null) searchButtonContainer.setVisibility(View.VISIBLE);
3514 searchButton.setVisibility(View.VISIBLE);
Winson Chungbb185bd2011-11-21 12:31:42 -08003515 invalidatePressedFocusedStates(searchButtonContainer, searchButton);
Winson Chungc51db6a2011-10-05 11:44:49 -07003516 return true;
Winson Chung1cad91e2011-05-25 17:41:01 -07003517 } else {
Winson Chungcbf7c4d2011-08-23 11:58:54 -07003518 // We disable both search and voice search when there is no global search provider
Winson Chungc51db6a2011-10-05 11:44:49 -07003519 if (searchButtonContainer != null) searchButtonContainer.setVisibility(View.GONE);
3520 if (voiceButtonContainer != null) voiceButtonContainer.setVisibility(View.GONE);
John Spurlock2c38e702013-09-18 10:48:25 -04003521 if (searchButton != null) searchButton.setVisibility(View.GONE);
3522 if (voiceButton != null) voiceButton.setVisibility(View.GONE);
Winson Chung5841efa2013-09-30 18:06:44 -07003523 updateVoiceButtonProxyVisible(false);
Winson Chungc51db6a2011-10-05 11:44:49 -07003524 return false;
Amith Yamasani6d7fe502010-11-16 09:05:07 -08003525 }
3526 }
3527
Cristina Stancu476493b2013-08-07 17:20:14 +01003528 protected void updateGlobalSearchIcon(Drawable.ConstantState d) {
Winson Chungbb185bd2011-11-21 12:31:42 -08003529 final View searchButtonContainer = findViewById(R.id.search_button_container);
3530 final View searchButton = (ImageView) findViewById(R.id.search_button);
Michael Jurka4ef207b2010-11-29 17:05:45 -08003531 updateButtonWithDrawable(R.id.search_button, d);
Winson Chungbb185bd2011-11-21 12:31:42 -08003532 invalidatePressedFocusedStates(searchButtonContainer, searchButton);
Michael Jurka4ef207b2010-11-29 17:05:45 -08003533 }
3534
Cristina Stancu476493b2013-08-07 17:20:14 +01003535 protected boolean updateVoiceSearchIcon(boolean searchVisible) {
Winson Chungc51db6a2011-10-05 11:44:49 -07003536 final View voiceButtonContainer = findViewById(R.id.voice_button_container);
Winson Chung1cad91e2011-05-25 17:41:01 -07003537 final View voiceButton = findViewById(R.id.voice_button);
Winson Chung97d85d22011-04-13 11:27:36 -07003538
Winson Chungc51db6a2011-10-05 11:44:49 -07003539 // We only show/update the voice search icon if the search icon is enabled as well
Michael Jurkaae65ee32012-04-30 11:45:54 -07003540 final SearchManager searchManager =
3541 (SearchManager) getSystemService(Context.SEARCH_SERVICE);
3542 ComponentName globalSearchActivity = searchManager.getGlobalSearchActivity();
3543
3544 ComponentName activityName = null;
3545 if (globalSearchActivity != null) {
3546 // Check if the global search activity handles voice search
3547 Intent intent = new Intent(RecognizerIntent.ACTION_WEB_SEARCH);
3548 intent.setPackage(globalSearchActivity.getPackageName());
3549 activityName = intent.resolveActivity(getPackageManager());
3550 }
3551
3552 if (activityName == null) {
3553 // Fallback: check if an activity other than the global search activity
3554 // resolves this
3555 Intent intent = new Intent(RecognizerIntent.ACTION_WEB_SEARCH);
3556 activityName = intent.resolveActivity(getPackageManager());
3557 }
Winson Chungc51db6a2011-10-05 11:44:49 -07003558 if (searchVisible && activityName != null) {
Winson Chungdff8ebb2011-09-08 17:25:31 -07003559 int coi = getCurrentOrientationIndexForGlobalIcons();
3560 sVoiceSearchIcon[coi] = updateButtonWithIconFromExternalActivity(
Michael Jurkaae65ee32012-04-30 11:45:54 -07003561 R.id.voice_button, activityName, R.drawable.ic_home_voice_search_holo,
3562 TOOLBAR_VOICE_SEARCH_ICON_METADATA_NAME);
3563 if (sVoiceSearchIcon[coi] == null) {
3564 sVoiceSearchIcon[coi] = updateButtonWithIconFromExternalActivity(
3565 R.id.voice_button, activityName, R.drawable.ic_home_voice_search_holo,
3566 TOOLBAR_ICON_METADATA_NAME);
3567 }
Winson Chungc51db6a2011-10-05 11:44:49 -07003568 if (voiceButtonContainer != null) voiceButtonContainer.setVisibility(View.VISIBLE);
Winson Chung1cad91e2011-05-25 17:41:01 -07003569 voiceButton.setVisibility(View.VISIBLE);
Winson Chung5841efa2013-09-30 18:06:44 -07003570 updateVoiceButtonProxyVisible(false);
Winson Chungbb185bd2011-11-21 12:31:42 -08003571 invalidatePressedFocusedStates(voiceButtonContainer, voiceButton);
Winson Chungc51db6a2011-10-05 11:44:49 -07003572 return true;
Winson Chung1cad91e2011-05-25 17:41:01 -07003573 } else {
Winson Chungc51db6a2011-10-05 11:44:49 -07003574 if (voiceButtonContainer != null) voiceButtonContainer.setVisibility(View.GONE);
John Spurlock2c38e702013-09-18 10:48:25 -04003575 if (voiceButton != null) voiceButton.setVisibility(View.GONE);
Winson Chung5841efa2013-09-30 18:06:44 -07003576 updateVoiceButtonProxyVisible(false);
Winson Chungc51db6a2011-10-05 11:44:49 -07003577 return false;
Patrick Dubroyceae05d2010-08-30 10:40:53 -07003578 }
Michael Jurka6ae0fcf2010-10-01 12:23:12 -07003579 }
Michael Jurka0423dcf2010-10-05 14:56:18 -07003580
Cristina Stancu476493b2013-08-07 17:20:14 +01003581 protected void updateVoiceSearchIcon(Drawable.ConstantState d) {
Winson Chungbb185bd2011-11-21 12:31:42 -08003582 final View voiceButtonContainer = findViewById(R.id.voice_button_container);
3583 final View voiceButton = findViewById(R.id.voice_button);
Michael Jurka4ef207b2010-11-29 17:05:45 -08003584 updateButtonWithDrawable(R.id.voice_button, d);
Winson Chungbb185bd2011-11-21 12:31:42 -08003585 invalidatePressedFocusedStates(voiceButtonContainer, voiceButton);
Michael Jurka4ef207b2010-11-29 17:05:45 -08003586 }
3587
Winson Chung5841efa2013-09-30 18:06:44 -07003588 public void updateVoiceButtonProxyVisible(boolean forceDisableVoiceButtonProxy) {
Bjorn Bringertecf33e42013-06-11 15:46:07 +01003589 final View voiceButtonProxy = findViewById(R.id.voice_button_proxy);
3590 if (voiceButtonProxy != null) {
Winson Chung5841efa2013-09-30 18:06:44 -07003591 boolean visible = !forceDisableVoiceButtonProxy &&
3592 mWorkspace.shouldVoiceButtonProxyBeVisible();
Bjorn Bringertecf33e42013-06-11 15:46:07 +01003593 voiceButtonProxy.setVisibility(visible ? View.VISIBLE : View.GONE);
Winson Chung5841efa2013-09-30 18:06:44 -07003594 voiceButtonProxy.bringToFront();
Bjorn Bringertecf33e42013-06-11 15:46:07 +01003595 }
3596 }
Winson Chung5841efa2013-09-30 18:06:44 -07003597
3598 /**
3599 * This is an overrid eot disable the voice button proxy. If disabled is true, then the voice button proxy
3600 * will be hidden regardless of what shouldVoiceButtonProxyBeVisible() returns.
3601 */
3602 public void disableVoiceButtonProxy(boolean disabled) {
3603 updateVoiceButtonProxyVisible(disabled);
3604 }
Michael Jurka6ae0fcf2010-10-01 12:23:12 -07003605 /**
Winson Chungeb66b142011-06-16 13:14:22 -07003606 * Sets the app market icon
Michael Jurka6ae0fcf2010-10-01 12:23:12 -07003607 */
3608 private void updateAppMarketIcon() {
Winson Chungd64a6662013-09-30 11:06:59 -07003609 if (!DISABLE_MARKET_BUTTON) {
3610 final View marketButton = findViewById(R.id.market_button);
3611 Intent intent = new Intent(Intent.ACTION_MAIN).addCategory(Intent.CATEGORY_APP_MARKET);
3612 // Find the app market activity by resolving an intent.
3613 // (If multiple app markets are installed, it will return the ResolverActivity.)
3614 ComponentName activityName = intent.resolveActivity(getPackageManager());
3615 if (activityName != null) {
3616 int coi = getCurrentOrientationIndexForGlobalIcons();
3617 mAppMarketIntent = intent;
3618 sAppMarketIcon[coi] = updateTextButtonWithIconFromExternalActivity(
3619 R.id.market_button, activityName, R.drawable.ic_launcher_market_holo,
3620 TOOLBAR_ICON_METADATA_NAME);
3621 marketButton.setVisibility(View.VISIBLE);
3622 } else {
3623 // We should hide and disable the view so that we don't try and restore the visibility
3624 // of it when we swap between drag & normal states from IconDropTarget subclasses.
3625 marketButton.setVisibility(View.GONE);
3626 marketButton.setEnabled(false);
3627 }
Michael Jurka0423dcf2010-10-05 14:56:18 -07003628 }
Patrick Dubroyceae05d2010-08-30 10:40:53 -07003629 }
3630
Michael Jurkae7bf83b2010-12-14 18:02:21 -08003631 private void updateAppMarketIcon(Drawable.ConstantState d) {
Winson Chungd64a6662013-09-30 11:06:59 -07003632 if (!DISABLE_MARKET_BUTTON) {
3633 // Ensure that the new drawable we are creating has the approprate toolbar icon bounds
3634 Resources r = getResources();
3635 Drawable marketIconDrawable = d.newDrawable(r);
3636 int w = r.getDimensionPixelSize(R.dimen.toolbar_external_icon_width);
3637 int h = r.getDimensionPixelSize(R.dimen.toolbar_external_icon_height);
3638 marketIconDrawable.setBounds(0, 0, w, h);
Winson Chung1b884092012-06-08 17:13:02 -07003639
Winson Chungd64a6662013-09-30 11:06:59 -07003640 updateTextButtonWithDrawable(R.id.market_button, marketIconDrawable);
3641 }
Michael Jurka4ef207b2010-11-29 17:05:45 -08003642 }
3643
Michael Jurkad7c28052012-04-27 15:43:36 -07003644 @Override
3645 public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
alanv1d4fde62012-10-17 13:15:47 -07003646 final boolean result = super.dispatchPopulateAccessibilityEvent(event);
Michael Jurkad7c28052012-04-27 15:43:36 -07003647 final List<CharSequence> text = event.getText();
3648 text.clear();
alanv1d4fde62012-10-17 13:15:47 -07003649 // Populate event with a fake title based on the current state.
3650 if (mState == State.APPS_CUSTOMIZE) {
Adam Cohen4b378872013-10-04 18:58:04 -07003651 text.add(mAppsCustomizeTabHost.getCurrentTabView().getContentDescription());
alanv1d4fde62012-10-17 13:15:47 -07003652 } else {
3653 text.add(getString(R.string.all_apps_home_button_label));
3654 }
Michael Jurkad7c28052012-04-27 15:43:36 -07003655 return result;
3656 }
3657
Patrick Dubroyceae05d2010-08-30 10:40:53 -07003658 /**
Winson Chungb8472bb2011-08-05 13:49:21 -07003659 * Receives notifications when system dialogs are to be closed.
Joe Onorato2ca0ae72009-11-10 13:14:13 -08003660 */
3661 private class CloseSystemDialogsIntentReceiver extends BroadcastReceiver {
3662 @Override
3663 public void onReceive(Context context, Intent intent) {
Joe Onorato2ca0ae72009-11-10 13:14:13 -08003664 closeSystemDialogs();
3665 }
3666 }
3667
3668 /**
Jeff Sharkey1e2efc82009-11-06 15:17:59 -08003669 * Receives notifications whenever the appwidgets are reset.
3670 */
3671 private class AppWidgetResetObserver extends ContentObserver {
3672 public AppWidgetResetObserver() {
3673 super(new Handler());
3674 }
3675
3676 @Override
3677 public void onChange(boolean selfChange) {
3678 onAppWidgetReset();
3679 }
3680 }
3681
3682 /**
Michael Jurka7607c2f2013-04-03 14:33:19 -07003683 * If the activity is currently paused, signal that we need to run the passed Runnable
3684 * in onResume.
3685 *
3686 * This needs to be called from incoming places where resources might have been loaded
3687 * while we are paused. That is becaues the Configuration might be wrong
3688 * when we're not running, and if it comes back to what it was when we
3689 * were paused, we are not restarted.
3690 *
3691 * Implementation of the method from LauncherModel.Callbacks.
3692 *
3693 * @return true if we are currently paused. The caller might be able to
3694 * skip some work in that case since we will come back again.
3695 */
Michael Jurkac402cd92013-05-20 15:49:32 +02003696 private boolean waitUntilResume(Runnable run, boolean deletePreviousRunnables) {
Michael Jurka7607c2f2013-04-03 14:33:19 -07003697 if (mPaused) {
3698 Log.i(TAG, "Deferring update until onResume");
Michael Jurkac402cd92013-05-20 15:49:32 +02003699 if (deletePreviousRunnables) {
Michael Jurka1e2f4652013-07-08 18:03:46 -07003700 while (mBindOnResumeCallbacks.remove(run)) {
Michael Jurkac402cd92013-05-20 15:49:32 +02003701 }
3702 }
Michael Jurka1e2f4652013-07-08 18:03:46 -07003703 mBindOnResumeCallbacks.add(run);
Michael Jurka7607c2f2013-04-03 14:33:19 -07003704 return true;
3705 } else {
3706 return false;
3707 }
3708 }
3709
Michael Jurkac402cd92013-05-20 15:49:32 +02003710 private boolean waitUntilResume(Runnable run) {
3711 return waitUntilResume(run, false);
3712 }
3713
Michael Jurka1e2f4652013-07-08 18:03:46 -07003714 public void addOnResumeCallback(Runnable run) {
Michael Jurka54554252013-08-01 12:52:23 +02003715 mOnResumeCallbacks.add(run);
Michael Jurka1e2f4652013-07-08 18:03:46 -07003716 }
3717
Michael Jurka7607c2f2013-04-03 14:33:19 -07003718 /**
Joe Onoratoef2efcf2010-10-27 13:21:00 -07003719 * If the activity is currently paused, signal that we need to re-run the loader
3720 * in onResume.
3721 *
3722 * This needs to be called from incoming places where resources might have been loaded
3723 * while we are paused. That is becaues the Configuration might be wrong
3724 * when we're not running, and if it comes back to what it was when we
3725 * were paused, we are not restarted.
3726 *
3727 * Implementation of the method from LauncherModel.Callbacks.
3728 *
3729 * @return true if we are currently paused. The caller might be able to
3730 * skip some work in that case since we will come back again.
3731 */
3732 public boolean setLoadOnResume() {
3733 if (mPaused) {
3734 Log.i(TAG, "setLoadOnResume");
3735 mOnResumeNeedsLoad = true;
3736 return true;
3737 } else {
3738 return false;
3739 }
3740 }
3741
3742 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04003743 * Implementation of the method from LauncherModel.Callbacks.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003744 */
Joe Onorato9c1289c2009-08-17 11:03:03 -04003745 public int getCurrentWorkspaceScreen() {
Joe Onoratod0afc872010-06-11 00:03:15 -07003746 if (mWorkspace != null) {
Michael Jurka0142d492010-08-25 17:46:15 -07003747 return mWorkspace.getCurrentPage();
Joe Onoratod0afc872010-06-11 00:03:15 -07003748 } else {
3749 return SCREEN_COUNT / 2;
3750 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04003751 }
The Android Open Source Projectf96811c2009-03-18 17:39:48 -07003752
Joe Onorato9c1289c2009-08-17 11:03:03 -04003753 /**
3754 * Refreshes the shortcuts shown on the workspace.
3755 *
3756 * Implementation of the method from LauncherModel.Callbacks.
3757 */
3758 public void startBinding() {
Michael Jurka7607c2f2013-04-03 14:33:19 -07003759 // If we're starting binding all over again, clear any bind calls we'd postponed in
3760 // the past (see waitUntilResume) -- we don't need them since we're starting binding
3761 // from scratch again
Michael Jurka1e2f4652013-07-08 18:03:46 -07003762 mBindOnResumeCallbacks.clear();
Adam Cohendf035382011-04-11 17:22:04 -07003763
Winson Chungd64d1762013-08-20 14:37:16 -07003764 // Clear the workspace because it's going to be rebound
Adam Cohendf035382011-04-11 17:22:04 -07003765 mWorkspace.clearDropTargets();
Winson Chung9e6a0a22013-08-27 11:58:12 -07003766 mWorkspace.removeAllWorkspaceScreens();
Winson Chungd64d1762013-08-20 14:37:16 -07003767
Michael Jurka05bf6442011-11-30 20:28:53 -08003768 mWidgetsToAdvance.clear();
Winson Chung3d503fb2011-07-13 17:25:49 -07003769 if (mHotseat != null) {
3770 mHotseat.resetLayout();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003771 }
3772 }
3773
Adam Cohendcd297f2013-06-18 13:13:40 -07003774 @Override
3775 public void bindScreens(ArrayList<Long> orderedScreenIds) {
Winson Chung64359a52013-07-08 17:17:08 -07003776 bindAddScreens(orderedScreenIds);
Winson Chung0e6a7132013-08-23 12:55:10 -07003777
Adam Cohen5084cba2013-09-03 12:01:16 -07003778 // If there are no screens, we need to have an empty screen
3779 if (orderedScreenIds.size() == 0) {
3780 mWorkspace.addExtraEmptyScreen();
3781 }
Winson Chung0e6a7132013-08-23 12:55:10 -07003782
3783 // Create the custom content page (this call updates mDefaultScreen which calls
Dave Hawkeya8881582013-09-17 15:55:33 -06003784 // setCurrentPage() so ensure that all pages are added before calling this).
Derek Prothrodadd9842014-01-17 13:43:50 -05003785 if (hasCustomContentToLeft()) {
3786 mWorkspace.createCustomContentContainer();
3787 populateCustomContentContainer();
Winson Chung0e6a7132013-08-23 12:55:10 -07003788 }
Winson Chung64359a52013-07-08 17:17:08 -07003789 }
3790
3791 @Override
3792 public void bindAddScreens(ArrayList<Long> orderedScreenIds) {
Winson Chunga90303b2013-11-15 13:05:06 -08003793 // Log to disk
3794 Launcher.addDumpLog(TAG, "11683562 - bindAddScreens()", true);
3795 Launcher.addDumpLog(TAG, "11683562 - orderedScreenIds: " +
3796 TextUtils.join(", ", orderedScreenIds), true);
Adam Cohendcd297f2013-06-18 13:13:40 -07003797 int count = orderedScreenIds.size();
3798 for (int i = 0; i < count; i++) {
Adam Cohen89bddfa2013-08-20 11:57:13 -07003799 mWorkspace.insertNewWorkspaceScreenBeforeEmptyScreen(orderedScreenIds.get(i));
Adam Cohendcd297f2013-06-18 13:13:40 -07003800 }
Adam Cohendcd297f2013-06-18 13:13:40 -07003801 }
3802
Adam Cohen39a06042013-07-19 14:30:12 -07003803 private boolean shouldShowWeightWatcher() {
3804 String spKey = LauncherAppState.getSharedPreferencesKey();
3805 SharedPreferences sp = getSharedPreferences(spKey, Context.MODE_PRIVATE);
Daniel Sandler6053b802013-08-15 15:44:26 -07003806 boolean show = sp.getBoolean(SHOW_WEIGHT_WATCHER, SHOW_WEIGHT_WATCHER_DEFAULT);
Adam Cohen39a06042013-07-19 14:30:12 -07003807
3808 return show;
3809 }
3810
3811 private void toggleShowWeightWatcher() {
3812 String spKey = LauncherAppState.getSharedPreferencesKey();
3813 SharedPreferences sp = getSharedPreferences(spKey, Context.MODE_PRIVATE);
3814 boolean show = sp.getBoolean(SHOW_WEIGHT_WATCHER, true);
3815
3816 show = !show;
3817
3818 SharedPreferences.Editor editor = sp.edit();
3819 editor.putBoolean(SHOW_WEIGHT_WATCHER, show);
3820 editor.commit();
3821
3822 if (mWeightWatcher != null) {
3823 mWeightWatcher.setVisibility(show ? View.VISIBLE : View.GONE);
3824 }
3825 }
3826
Winson Chungd64d1762013-08-20 14:37:16 -07003827 public void bindAppsAdded(final ArrayList<Long> newScreens,
3828 final ArrayList<ItemInfo> addNotAnimated,
Winson Chungc58497e2013-09-03 17:48:37 -07003829 final ArrayList<ItemInfo> addAnimated,
3830 final ArrayList<AppInfo> addedApps) {
Winson Chungd64d1762013-08-20 14:37:16 -07003831 Runnable r = new Runnable() {
3832 public void run() {
Winson Chungc58497e2013-09-03 17:48:37 -07003833 bindAppsAdded(newScreens, addNotAnimated, addAnimated, addedApps);
Winson Chungd64d1762013-08-20 14:37:16 -07003834 }
3835 };
3836 if (waitUntilResume(r)) {
3837 return;
3838 }
3839
Winson Chungd64d1762013-08-20 14:37:16 -07003840 // Add the new screens
3841 bindAddScreens(newScreens);
3842
3843 // We add the items without animation on non-visible pages, and with
3844 // animations on the new page (which we will try and snap to).
3845 if (!addNotAnimated.isEmpty()) {
3846 bindItems(addNotAnimated, 0,
3847 addNotAnimated.size(), false);
3848 }
3849 if (!addAnimated.isEmpty()) {
3850 bindItems(addAnimated, 0,
3851 addAnimated.size(), true);
3852 }
Winson Chungc58497e2013-09-03 17:48:37 -07003853
Winson Chung87412982013-10-03 18:34:14 -07003854 // Remove the extra empty screen
Adam Cohenad4e15c2013-10-17 16:21:35 -07003855 mWorkspace.removeExtraEmptyScreen(false, null);
Winson Chung87412982013-10-03 18:34:14 -07003856
Nilesh Agrawal16f3ea82014-01-09 17:14:01 -08003857 if (!LauncherAppState.isDisableAllApps() &&
Winson Chungc58497e2013-09-03 17:48:37 -07003858 addedApps != null && mAppsCustomizeContent != null) {
3859 mAppsCustomizeContent.addApps(addedApps);
3860 }
Winson Chungd64d1762013-08-20 14:37:16 -07003861 }
3862
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003863 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04003864 * Bind the items start-end from the list.
3865 *
3866 * Implementation of the method from LauncherModel.Callbacks.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003867 */
Winson Chung64359a52013-07-08 17:17:08 -07003868 public void bindItems(final ArrayList<ItemInfo> shortcuts, final int start, final int end,
3869 final boolean forceAnimateIcons) {
Winson Chungd64d1762013-08-20 14:37:16 -07003870 Runnable r = new Runnable() {
3871 public void run() {
3872 bindItems(shortcuts, start, end, forceAnimateIcons);
3873 }
3874 };
3875 if (waitUntilResume(r)) {
Michael Jurka7607c2f2013-04-03 14:33:19 -07003876 return;
3877 }
Joe Onoratoef2efcf2010-10-27 13:21:00 -07003878
Winson Chungf0c6ae02012-03-21 16:10:31 -07003879 // Get the list of added shortcuts and intersect them with the set of shortcuts here
Winson Chung64359a52013-07-08 17:17:08 -07003880 final AnimatorSet anim = LauncherAnimUtils.createAnimatorSet();
3881 final Collection<Animator> bounceAnims = new ArrayList<Animator>();
Winson Chung997a9232013-07-24 15:33:46 -07003882 final boolean animateIcons = forceAnimateIcons && canRunNewAppsAnimation();
Winson Chungf0c6ae02012-03-21 16:10:31 -07003883 Workspace workspace = mWorkspace;
Winson Chung997a9232013-07-24 15:33:46 -07003884 long newShortcutsScreenId = -1;
Winson Chungf0c6ae02012-03-21 16:10:31 -07003885 for (int i = start; i < end; i++) {
Joe Onorato9c1289c2009-08-17 11:03:03 -04003886 final ItemInfo item = shortcuts.get(i);
Winson Chung4d279d92011-07-21 11:46:32 -07003887
3888 // Short circuit if we are loading dock items for a configuration which has no dock
3889 if (item.container == LauncherSettings.Favorites.CONTAINER_HOTSEAT &&
3890 mHotseat == null) {
3891 continue;
3892 }
3893
Joe Onorato9c1289c2009-08-17 11:03:03 -04003894 switch (item.itemType) {
3895 case LauncherSettings.Favorites.ITEM_TYPE_APPLICATION:
3896 case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT:
Winson Chungf0c6ae02012-03-21 16:10:31 -07003897 ShortcutInfo info = (ShortcutInfo) item;
Winson Chungf0c6ae02012-03-21 16:10:31 -07003898 View shortcut = createShortcut(info);
Adam Cohendcd297f2013-06-18 13:13:40 -07003899
Winson Chung64359a52013-07-08 17:17:08 -07003900 /*
3901 * TODO: FIX collision case
3902 */
Winson Chungce376632013-07-11 16:12:41 -07003903 if (item.container == LauncherSettings.Favorites.CONTAINER_DESKTOP) {
3904 CellLayout cl = mWorkspace.getScreenWithId(item.screenId);
3905 if (cl != null && cl.isOccupied(item.cellX, item.cellY)) {
3906 throw new RuntimeException("OCCUPIED");
3907 }
Winson Chung64359a52013-07-08 17:17:08 -07003908 }
3909
Adam Cohendcd297f2013-06-18 13:13:40 -07003910 workspace.addInScreenFromBind(shortcut, item.container, item.screenId, item.cellX,
3911 item.cellY, 1, 1);
Winson Chung997a9232013-07-24 15:33:46 -07003912 if (animateIcons) {
Winson Chung64359a52013-07-08 17:17:08 -07003913 // Animate all the applications up now
3914 shortcut.setAlpha(0f);
3915 shortcut.setScaleX(0f);
3916 shortcut.setScaleY(0f);
3917 bounceAnims.add(createNewAppBounceAnimation(shortcut, i));
Winson Chung997a9232013-07-24 15:33:46 -07003918 newShortcutsScreenId = item.screenId;
Winson Chungf0c6ae02012-03-21 16:10:31 -07003919 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04003920 break;
Adam Cohendf2cc412011-04-27 16:56:57 -07003921 case LauncherSettings.Favorites.ITEM_TYPE_FOLDER:
Winson Chung3d503fb2011-07-13 17:25:49 -07003922 FolderIcon newFolder = FolderIcon.fromXml(R.layout.folder_icon, this,
Michael Jurka0142d492010-08-25 17:46:15 -07003923 (ViewGroup) workspace.getChildAt(workspace.getCurrentPage()),
Adam Cohendf2cc412011-04-27 16:56:57 -07003924 (FolderInfo) item, mIconCache);
Adam Cohendcd297f2013-06-18 13:13:40 -07003925 workspace.addInScreenFromBind(newFolder, item.container, item.screenId, item.cellX,
3926 item.cellY, 1, 1);
Joe Onorato9c1289c2009-08-17 11:03:03 -04003927 break;
Winson Chungc763c4e2013-07-19 13:49:06 -07003928 default:
3929 throw new RuntimeException("Invalid Item Type");
Joe Onorato9c1289c2009-08-17 11:03:03 -04003930 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003931 }
Winson Chungf0c6ae02012-03-21 16:10:31 -07003932
Winson Chung997a9232013-07-24 15:33:46 -07003933 if (animateIcons) {
3934 // Animate to the correct page
3935 if (newShortcutsScreenId > -1) {
3936 long currentScreenId = mWorkspace.getScreenIdForPageIndex(mWorkspace.getNextPage());
Winson Chung94d67682013-09-25 16:29:40 -07003937 final int newScreenIndex = mWorkspace.getPageIndexForScreenId(newShortcutsScreenId);
Winson Chungb2323832013-10-03 15:22:09 -07003938 final Runnable startBounceAnimRunnable = new Runnable() {
3939 public void run() {
3940 anim.playTogether(bounceAnims);
3941 anim.start();
3942 }
3943 };
Winson Chung997a9232013-07-24 15:33:46 -07003944 if (newShortcutsScreenId != currentScreenId) {
Winson Chung94d67682013-09-25 16:29:40 -07003945 // We post the animation slightly delayed to prevent slowdowns
3946 // when we are loading right after we return to launcher.
3947 mWorkspace.postDelayed(new Runnable() {
3948 public void run() {
Ian Parkinson94449152014-01-21 13:09:59 +00003949 if (mWorkspace != null) {
3950 mWorkspace.snapToPage(newScreenIndex);
3951 mWorkspace.postDelayed(startBounceAnimRunnable,
3952 NEW_APPS_ANIMATION_DELAY);
3953 }
Winson Chung94d67682013-09-25 16:29:40 -07003954 }
3955 }, NEW_APPS_PAGE_MOVE_DELAY);
Winson Chungb2323832013-10-03 15:22:09 -07003956 } else {
3957 mWorkspace.postDelayed(startBounceAnimRunnable, NEW_APPS_ANIMATION_DELAY);
Winson Chung997a9232013-07-24 15:33:46 -07003958 }
3959 }
Winson Chung64359a52013-07-08 17:17:08 -07003960 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04003961 workspace.requestLayout();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003962 }
3963
Joe Onorato9c1289c2009-08-17 11:03:03 -04003964 /**
3965 * Implementation of the method from LauncherModel.Callbacks.
3966 */
Michael Jurka7607c2f2013-04-03 14:33:19 -07003967 public void bindFolders(final HashMap<Long, FolderInfo> folders) {
Winson Chungd64d1762013-08-20 14:37:16 -07003968 Runnable r = new Runnable() {
3969 public void run() {
3970 bindFolders(folders);
3971 }
3972 };
3973 if (waitUntilResume(r)) {
Michael Jurka7607c2f2013-04-03 14:33:19 -07003974 return;
3975 }
Brad Fitzpatrick319226a2010-09-01 13:45:16 -07003976 sFolders.clear();
3977 sFolders.putAll(folders);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003978 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04003979
3980 /**
3981 * Add the views for a widget to the workspace.
3982 *
3983 * Implementation of the method from LauncherModel.Callbacks.
3984 */
Michael Jurka7607c2f2013-04-03 14:33:19 -07003985 public void bindAppWidget(final LauncherAppWidgetInfo item) {
Winson Chungd64d1762013-08-20 14:37:16 -07003986 Runnable r = new Runnable() {
3987 public void run() {
3988 bindAppWidget(item);
3989 }
3990 };
3991 if (waitUntilResume(r)) {
Michael Jurka7607c2f2013-04-03 14:33:19 -07003992 return;
3993 }
Joe Onoratoef2efcf2010-10-27 13:21:00 -07003994
Daniel Sandler843e8602010-06-07 14:59:01 -04003995 final long start = DEBUG_WIDGETS ? SystemClock.uptimeMillis() : 0;
3996 if (DEBUG_WIDGETS) {
3997 Log.d(TAG, "bindAppWidget: " + item);
3998 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04003999 final Workspace workspace = mWorkspace;
4000
4001 final int appWidgetId = item.appWidgetId;
4002 final AppWidgetProviderInfo appWidgetInfo = mAppWidgetManager.getAppWidgetInfo(appWidgetId);
Daniel Sandler843e8602010-06-07 14:59:01 -04004003 if (DEBUG_WIDGETS) {
4004 Log.d(TAG, "bindAppWidget: id=" + item.appWidgetId + " belongs to component " + appWidgetInfo.provider);
4005 }
4006
Joe Onorato9c1289c2009-08-17 11:03:03 -04004007 item.hostView = mAppWidgetHost.createView(this, appWidgetId, appWidgetInfo);
4008
Joe Onorato9c1289c2009-08-17 11:03:03 -04004009 item.hostView.setTag(item);
Winson Chung211bac32012-05-15 13:43:57 -07004010 item.onBindAppWidget(this);
Joe Onorato9c1289c2009-08-17 11:03:03 -04004011
Adam Cohendcd297f2013-06-18 13:13:40 -07004012 workspace.addInScreen(item.hostView, item.container, item.screenId, item.cellX,
Joe Onorato9c1289c2009-08-17 11:03:03 -04004013 item.cellY, item.spanX, item.spanY, false);
Adam Cohended9f8d2010-11-03 13:25:16 -07004014 addWidgetToAutoAdvanceIfNeeded(item.hostView, appWidgetInfo);
4015
Joe Onorato9c1289c2009-08-17 11:03:03 -04004016 workspace.requestLayout();
4017
Daniel Sandler843e8602010-06-07 14:59:01 -04004018 if (DEBUG_WIDGETS) {
4019 Log.d(TAG, "bound widget id="+item.appWidgetId+" in "
4020 + (SystemClock.uptimeMillis()-start) + "ms");
4021 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04004022 }
4023
Adam Cohen1462de32012-07-24 22:34:36 -07004024 public void onPageBoundSynchronously(int page) {
4025 mSynchronouslyBoundPages.add(page);
4026 }
4027
Joe Onorato9c1289c2009-08-17 11:03:03 -04004028 /**
4029 * Callback saying that there aren't any more items to bind.
4030 *
4031 * Implementation of the method from LauncherModel.Callbacks.
4032 */
Adam Cohene25af792013-06-06 23:08:25 -07004033 public void finishBindingItems(final boolean upgradePath) {
Winson Chungd64d1762013-08-20 14:37:16 -07004034 Runnable r = new Runnable() {
4035 public void run() {
4036 finishBindingItems(upgradePath);
4037 }
4038 };
4039 if (waitUntilResume(r)) {
Michael Jurka7607c2f2013-04-03 14:33:19 -07004040 return;
4041 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04004042 if (mSavedState != null) {
4043 if (!mWorkspace.hasFocus()) {
Michael Jurka0142d492010-08-25 17:46:15 -07004044 mWorkspace.getChildAt(mWorkspace.getCurrentPage()).requestFocus();
Joe Onorato9c1289c2009-08-17 11:03:03 -04004045 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04004046 mSavedState = null;
4047 }
4048
Adam Cohen1462de32012-07-24 22:34:36 -07004049 mWorkspace.restoreInstanceStateForRemainingPages();
Joe Onorato9c1289c2009-08-17 11:03:03 -04004050
Patrick Dubroy002cbf42011-03-03 16:36:21 -08004051 // If we received the result of any pending adds while the loader was running (e.g. the
4052 // widget configuration forced an orientation change), process them now.
4053 for (int i = 0; i < sPendingAddList.size(); i++) {
4054 completeAdd(sPendingAddList.get(i));
4055 }
4056 sPendingAddList.clear();
Joe Onorato9c1289c2009-08-17 11:03:03 -04004057
Winson Chungc51db6a2011-10-05 11:44:49 -07004058 // Update the market app icon as necessary (the other icons will be managed in response to
4059 // package changes in bindSearchablesChanged()
Winson Chungd64a6662013-09-30 11:06:59 -07004060 if (!DISABLE_MARKET_BUTTON) {
4061 updateAppMarketIcon();
4062 }
Michael Jurkac1f5d262011-09-30 19:32:27 -07004063
Winson Chungf0c6ae02012-03-21 16:10:31 -07004064 mWorkspaceLoading = false;
Adam Cohene25af792013-06-06 23:08:25 -07004065 if (upgradePath) {
Adam Cohen4caf2982013-08-20 18:54:31 -07004066 mWorkspace.getUniqueComponents(true, null);
4067 mIntentsOnWorkspaceFromUpgradePath = mWorkspace.getUniqueComponents(true, null);
Adam Cohene25af792013-06-06 23:08:25 -07004068 }
Winson Chungf0c6ae02012-03-21 16:10:31 -07004069 }
4070
Winson Chunga0b7e862013-09-05 16:03:15 -07004071 public boolean isAllAppsButtonRank(int rank) {
4072 if (mHotseat != null) {
4073 return mHotseat.isAllAppsButtonRank(rank);
4074 }
4075 return false;
4076 }
4077
Winson Chunga2413752012-04-03 14:22:34 -07004078 private boolean canRunNewAppsAnimation() {
4079 long diff = System.currentTimeMillis() - mDragController.getLastGestureUpTime();
4080 return diff > (NEW_APPS_ANIMATION_INACTIVE_TIMEOUT_SECONDS * 1000);
4081 }
4082
Winson Chungc9168342013-06-26 14:54:55 -07004083 private ValueAnimator createNewAppBounceAnimation(View v, int i) {
4084 ValueAnimator bounceAnim = LauncherAnimUtils.ofPropertyValuesHolder(v,
4085 PropertyValuesHolder.ofFloat("alpha", 1f),
4086 PropertyValuesHolder.ofFloat("scaleX", 1f),
4087 PropertyValuesHolder.ofFloat("scaleY", 1f));
4088 bounceAnim.setDuration(InstallShortcutReceiver.NEW_SHORTCUT_BOUNCE_DURATION);
4089 bounceAnim.setStartDelay(i * InstallShortcutReceiver.NEW_SHORTCUT_STAGGER_DELAY);
4090 bounceAnim.setInterpolator(new SmoothPagedView.OvershootInterpolator());
4091 return bounceAnim;
4092 }
4093
Adam Cohen27772732013-11-11 14:00:56 +00004094 public boolean useVerticalBarLayout() {
4095 return LauncherAppState.getInstance().getDynamicGrid().
4096 getDeviceProfile().isVerticalBarLayout();
4097 }
4098
Mac Duy Hai6def4f92013-11-28 16:17:33 +00004099 protected Rect getSearchBarBounds() {
4100 return LauncherAppState.getInstance().getDynamicGrid().
4101 getDeviceProfile().getSearchBarBounds();
4102 }
4103
Narayan Kamathcb1a4772011-06-28 13:46:59 +01004104 @Override
4105 public void bindSearchablesChanged() {
Winson Chungc51db6a2011-10-05 11:44:49 -07004106 boolean searchVisible = updateGlobalSearchIcon();
4107 boolean voiceVisible = updateVoiceSearchIcon(searchVisible);
Winson Chungadf0c182012-08-23 14:59:07 -07004108 if (mSearchDropTargetBar != null) {
4109 mSearchDropTargetBar.onSearchPackagesChanged(searchVisible, voiceVisible);
4110 }
Narayan Kamathcb1a4772011-06-28 13:46:59 +01004111 }
4112
Amith Yamasani6d7fe502010-11-16 09:05:07 -08004113 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04004114 * Add the icons for all apps.
4115 *
4116 * Implementation of the method from LauncherModel.Callbacks.
4117 */
Michael Jurkaeadbfc52013-09-04 00:45:37 +02004118 public void bindAllApplications(final ArrayList<AppInfo> apps) {
Nilesh Agrawal16f3ea82014-01-09 17:14:01 -08004119 if (LauncherAppState.isDisableAllApps()) {
Winson Chungc58497e2013-09-03 17:48:37 -07004120 if (mIntentsOnWorkspaceFromUpgradePath != null) {
4121 if (LauncherModel.UPGRADE_USE_MORE_APPS_FOLDER) {
4122 getHotseat().addAllAppsFolder(mIconCache, apps,
4123 mIntentsOnWorkspaceFromUpgradePath, Launcher.this, mWorkspace);
4124 }
4125 mIntentsOnWorkspaceFromUpgradePath = null;
Daniel Sandler8707e0f2013-08-15 15:54:18 -07004126 }
Nilesh Agrawal306c1cf2013-12-12 14:56:00 -08004127 if (mAppsCustomizeContent != null) {
4128 mAppsCustomizeContent.onPackagesUpdated(
4129 LauncherModel.getSortedWidgetsAndShortcuts(this));
4130 }
Winson Chungc58497e2013-09-03 17:48:37 -07004131 } else {
Winson Chungad7db6e2013-10-08 14:01:06 -07004132 if (mAppsCustomizeContent != null) {
Winson Chungc58497e2013-09-03 17:48:37 -07004133 mAppsCustomizeContent.setApps(apps);
Winson Chung6e1c0d32013-10-25 15:24:24 -07004134 mAppsCustomizeContent.onPackagesUpdated(
4135 LauncherModel.getSortedWidgetsAndShortcuts(this));
Winson Chungc58497e2013-09-03 17:48:37 -07004136 }
Winson Chung785d2eb2011-04-14 16:08:02 -07004137 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04004138 }
4139
4140 /**
4141 * A package was updated.
4142 *
4143 * Implementation of the method from LauncherModel.Callbacks.
4144 */
Michael Jurkaeadbfc52013-09-04 00:45:37 +02004145 public void bindAppsUpdated(final ArrayList<AppInfo> apps) {
Winson Chungd64d1762013-08-20 14:37:16 -07004146 Runnable r = new Runnable() {
4147 public void run() {
4148 bindAppsUpdated(apps);
4149 }
4150 };
4151 if (waitUntilResume(r)) {
Michael Jurka7607c2f2013-04-03 14:33:19 -07004152 return;
4153 }
4154
Patrick Dubroyf5afda72011-02-28 12:04:18 -08004155 if (mWorkspace != null) {
4156 mWorkspace.updateShortcuts(apps);
4157 }
Winson Chungc58497e2013-09-03 17:48:37 -07004158
Nilesh Agrawal16f3ea82014-01-09 17:14:01 -08004159 if (!LauncherAppState.isDisableAllApps() &&
Winson Chungc58497e2013-09-03 17:48:37 -07004160 mAppsCustomizeContent != null) {
4161 mAppsCustomizeContent.updateApps(apps);
4162 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04004163 }
4164
4165 /**
Winson Chung83892cc2013-05-01 16:53:33 -07004166 * A package was uninstalled. We take both the super set of packageNames
4167 * in addition to specific applications to remove, the reason being that
4168 * this can be called when a package is updated as well. In that scenario,
4169 * we only remove specific components from the workspace, where as
4170 * package-removal should clear all items by package name.
Joe Onorato9c1289c2009-08-17 11:03:03 -04004171 *
4172 * Implementation of the method from LauncherModel.Callbacks.
4173 */
Winson Chung83892cc2013-05-01 16:53:33 -07004174 public void bindComponentsRemoved(final ArrayList<String> packageNames,
Winson Chungdf95eb12013-10-16 14:57:07 -07004175 final ArrayList<AppInfo> appInfos) {
Winson Chungd64d1762013-08-20 14:37:16 -07004176 Runnable r = new Runnable() {
Winson Chung83892cc2013-05-01 16:53:33 -07004177 public void run() {
Winson Chungdf95eb12013-10-16 14:57:07 -07004178 bindComponentsRemoved(packageNames, appInfos);
Winson Chung83892cc2013-05-01 16:53:33 -07004179 }
Winson Chungd64d1762013-08-20 14:37:16 -07004180 };
4181 if (waitUntilResume(r)) {
Winson Chung83892cc2013-05-01 16:53:33 -07004182 return;
4183 }
4184
Winson Chungdf95eb12013-10-16 14:57:07 -07004185 if (!packageNames.isEmpty()) {
Winson Chung83892cc2013-05-01 16:53:33 -07004186 mWorkspace.removeItemsByPackageName(packageNames);
Winson Chungdf95eb12013-10-16 14:57:07 -07004187 }
4188 if (!appInfos.isEmpty()) {
Winson Chung83892cc2013-05-01 16:53:33 -07004189 mWorkspace.removeItemsByApplicationInfo(appInfos);
Joe Onorato36115782010-06-17 13:28:48 -04004190 }
Winson Chungf0ea4d32011-06-06 14:27:16 -07004191
Winson Chunga1820962011-10-03 16:31:06 -07004192 // Notify the drag controller
Winson Chungdf95eb12013-10-16 14:57:07 -07004193 mDragController.onAppsRemoved(packageNames, appInfos);
Winson Chungc58497e2013-09-03 17:48:37 -07004194
Winson Chungdf95eb12013-10-16 14:57:07 -07004195 // Update AllApps
Nilesh Agrawal16f3ea82014-01-09 17:14:01 -08004196 if (!LauncherAppState.isDisableAllApps() &&
Winson Chungc58497e2013-09-03 17:48:37 -07004197 mAppsCustomizeContent != null) {
4198 mAppsCustomizeContent.removeApps(appInfos);
4199 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04004200 }
Joe Onoratobe386092009-11-17 17:32:16 -08004201
4202 /**
Winson Chung80baf5a2010-08-09 16:03:15 -07004203 * A number of packages were updated.
4204 */
Michael Jurkac402cd92013-05-20 15:49:32 +02004205 private ArrayList<Object> mWidgetsAndShortcuts;
4206 private Runnable mBindPackagesUpdatedRunnable = new Runnable() {
Winson Chung83892cc2013-05-01 16:53:33 -07004207 public void run() {
Michael Jurkac402cd92013-05-20 15:49:32 +02004208 bindPackagesUpdated(mWidgetsAndShortcuts);
4209 mWidgetsAndShortcuts = null;
Winson Chung83892cc2013-05-01 16:53:33 -07004210 }
Michael Jurkac402cd92013-05-20 15:49:32 +02004211 };
Michael Jurkac402cd92013-05-20 15:49:32 +02004212 public void bindPackagesUpdated(final ArrayList<Object> widgetsAndShortcuts) {
4213 if (waitUntilResume(mBindPackagesUpdatedRunnable, true)) {
4214 mWidgetsAndShortcuts = widgetsAndShortcuts;
Winson Chung83892cc2013-05-01 16:53:33 -07004215 return;
4216 }
4217
Winson Chung64359a52013-07-08 17:17:08 -07004218 // Update the widgets pane
Nilesh Agrawal306c1cf2013-12-12 14:56:00 -08004219 if (mAppsCustomizeContent != null) {
Michael Jurkac402cd92013-05-20 15:49:32 +02004220 mAppsCustomizeContent.onPackagesUpdated(widgetsAndShortcuts);
Winson Chung785d2eb2011-04-14 16:08:02 -07004221 }
Winson Chung80baf5a2010-08-09 16:03:15 -07004222 }
4223
Winson Chung400438b2011-01-16 17:53:48 -08004224 private int mapConfigurationOriActivityInfoOri(int configOri) {
4225 final Display d = getWindowManager().getDefaultDisplay();
4226 int naturalOri = Configuration.ORIENTATION_LANDSCAPE;
4227 switch (d.getRotation()) {
4228 case Surface.ROTATION_0:
4229 case Surface.ROTATION_180:
4230 // We are currently in the same basic orientation as the natural orientation
4231 naturalOri = configOri;
4232 break;
4233 case Surface.ROTATION_90:
4234 case Surface.ROTATION_270:
4235 // We are currently in the other basic orientation to the natural orientation
4236 naturalOri = (configOri == Configuration.ORIENTATION_LANDSCAPE) ?
4237 Configuration.ORIENTATION_PORTRAIT : Configuration.ORIENTATION_LANDSCAPE;
4238 break;
4239 }
4240
4241 int[] oriMap = {
4242 ActivityInfo.SCREEN_ORIENTATION_PORTRAIT,
4243 ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE,
4244 ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT,
4245 ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
4246 };
4247 // Since the map starts at portrait, we need to offset if this device's natural orientation
4248 // is landscape.
4249 int indexOffset = 0;
4250 if (naturalOri == Configuration.ORIENTATION_LANDSCAPE) {
4251 indexOffset = 1;
4252 }
4253 return oriMap[(d.getRotation() + indexOffset) % 4];
4254 }
Adam Cohen446e9402011-09-15 18:21:21 -07004255
Winson Chung4b919f82012-05-01 10:44:08 -07004256 public boolean isRotationEnabled() {
Michael Jurka0a457bf2012-11-19 14:05:05 -08004257 boolean enableRotation = sForceEnableRotation ||
Winson Chung4b919f82012-05-01 10:44:08 -07004258 getResources().getBoolean(R.bool.allow_rotation);
4259 return enableRotation;
Winson Chung400438b2011-01-16 17:53:48 -08004260 }
Winson Chung4b919f82012-05-01 10:44:08 -07004261 public void lockScreenOrientation() {
4262 if (isRotationEnabled()) {
4263 setRequestedOrientation(mapConfigurationOriActivityInfoOri(getResources()
4264 .getConfiguration().orientation));
4265 }
4266 }
4267 public void unlockScreenOrientation(boolean immediate) {
4268 if (isRotationEnabled()) {
4269 if (immediate) {
Winson Chung641d71d2012-04-26 15:58:01 -07004270 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
Winson Chung4b919f82012-05-01 10:44:08 -07004271 } else {
4272 mHandler.postDelayed(new Runnable() {
4273 public void run() {
4274 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
4275 }
4276 }, mRestoreScreenOrientationDelay);
Winson Chung641d71d2012-04-26 15:58:01 -07004277 }
Winson Chung4b919f82012-05-01 10:44:08 -07004278 }
Winson Chung400438b2011-01-16 17:53:48 -08004279 }
4280
Sandeep Siddharthad4d3d082013-12-26 15:42:52 -08004281 /**
4282 * Called when the SearchBar hint should be changed.
4283 *
4284 * @param hint the hint to be displayed in the search bar.
4285 */
4286 protected void onSearchBarHintChanged(String hint) {
Winson Chunga6945242014-01-08 14:04:34 -08004287 mLauncherClings.updateSearchBarHint(hint);
Sandeep Siddharthad4d3d082013-12-26 15:42:52 -08004288 }
4289
Winson Chunge43a1e72014-01-15 10:33:02 -08004290 protected boolean isLauncherPreinstalled() {
4291 PackageManager pm = getPackageManager();
4292 try {
4293 ApplicationInfo ai = pm.getApplicationInfo(getComponentName().getPackageName(), 0);
4294 if ((ai.flags & ApplicationInfo.FLAG_SYSTEM) != 0) {
4295 return true;
4296 } else {
4297 return false;
4298 }
4299 } catch (NameNotFoundException e) {
4300 e.printStackTrace();
4301 return false;
4302 }
4303 }
4304
Winson Chunge6eabff2013-09-24 11:01:23 -07004305 protected String getFirstRunClingSearchBarHint() {
4306 return "";
4307 }
4308 protected String getFirstRunCustomContentHint() {
4309 return "";
4310 }
Winson Chung3a6e7f32013-10-09 15:50:52 -07004311 protected int getFirstRunFocusedHotseatAppDrawableId() {
4312 return -1;
4313 }
4314 protected ComponentName getFirstRunFocusedHotseatAppComponentName() {
4315 return null;
4316 }
4317 protected int getFirstRunFocusedHotseatAppRank() {
4318 return -1;
4319 }
4320 protected String getFirstRunFocusedHotseatAppBubbleTitle() {
4321 return "";
4322 }
4323 protected String getFirstRunFocusedHotseatAppBubbleDescription() {
4324 return "";
4325 }
Winson Chunge6eabff2013-09-24 11:01:23 -07004326
Winson Chungaf40f202013-09-18 18:26:31 -07004327 public void dismissFirstRunCling(View v) {
Winson Chunga6945242014-01-08 14:04:34 -08004328 mLauncherClings.dismissFirstRunCling(v);
4329 }
4330 public void dismissMigrationClingCopyApps(View v) {
4331 mLauncherClings.dismissMigrationClingCopyApps(v);
4332 }
4333 public void dismissMigrationClingUseDefault(View v) {
4334 mLauncherClings.dismissMigrationClingUseDefault(v);
4335 }
4336 public void dismissMigrationWorkspaceCling(View v) {
4337 mLauncherClings.dismissMigrationWorkspaceCling(v);
Winson Chungaf40f202013-09-18 18:26:31 -07004338 }
Winson Chung82f55532011-08-09 14:14:23 -07004339 public void dismissWorkspaceCling(View v) {
Winson Chunga6945242014-01-08 14:04:34 -08004340 mLauncherClings.dismissWorkspaceCling(v);
Winson Chung7d7541e2011-09-16 20:14:36 -07004341 }
4342 public void dismissFolderCling(View v) {
Winson Chunga6945242014-01-08 14:04:34 -08004343 mLauncherClings.dismissFolderCling(v);
Winson Chung82f55532011-08-09 14:14:23 -07004344 }
4345
Winson Chunga6945242014-01-08 14:04:34 -08004346 private boolean shouldRunFirstRunActivity() {
Adam Cohenbc4539d2014-01-14 14:05:32 -08004347 return !ActivityManager.isRunningInTestHarness() &&
4348 !mSharedPrefs.getBoolean(FIRST_RUN_ACTIVITY_DISPLAYED, false);
Winson Chunga6945242014-01-08 14:04:34 -08004349 }
4350
4351 public void showFirstRunActivity() {
Adam Cohenbc4539d2014-01-14 14:05:32 -08004352 if (shouldRunFirstRunActivity() &&
4353 hasFirstRunActivity()) {
Winson Chunga6945242014-01-08 14:04:34 -08004354 Intent firstRunIntent = getFirstRunActivity();
4355 if (firstRunIntent != null) {
4356 startActivity(firstRunIntent);
4357 markFirstRunActivityShown();
4358 }
4359 }
4360 }
4361
4362 private void markFirstRunActivityShown() {
4363 SharedPreferences.Editor editor = mSharedPrefs.edit();
4364 editor.putBoolean(FIRST_RUN_ACTIVITY_DISPLAYED, true);
4365 editor.apply();
4366 }
4367
4368 void showWorkspaceSearchAndHotseat() {
Winson Chung205cd772014-01-15 14:31:59 -08004369 if (mWorkspace != null) mWorkspace.setAlpha(1f);
4370 if (mHotseat != null) mHotseat.setAlpha(1f);
4371 if (mPageIndicators != null) mPageIndicators.setAlpha(1f);
4372 if (mSearchDropTargetBar != null) mSearchDropTargetBar.showSearchBar(false);
Winson Chunga6945242014-01-08 14:04:34 -08004373 }
4374
4375 void hideWorkspaceSearchAndHotseat() {
Winson Chung205cd772014-01-15 14:31:59 -08004376 if (mWorkspace != null) mWorkspace.setAlpha(0f);
4377 if (mHotseat != null) mHotseat.setAlpha(0f);
4378 if (mPageIndicators != null) mPageIndicators.setAlpha(0f);
4379 if (mSearchDropTargetBar != null) mSearchDropTargetBar.hideSearchBar(false);
Winson Chunga6945242014-01-08 14:04:34 -08004380 }
4381
4382
Mathew Inwood72fbec12013-11-19 15:45:07 +00004383 public ItemInfo createAppDragInfo(Intent appLaunchIntent) {
4384 ResolveInfo ri = getPackageManager().resolveActivity(appLaunchIntent, 0);
4385 if (ri == null) {
4386 return null;
4387 }
4388 return new AppInfo(getPackageManager(), ri, mIconCache, null);
4389 }
4390
4391 public ItemInfo createShortcutDragInfo(Intent shortcutIntent, CharSequence caption,
4392 Bitmap icon) {
4393 return new ShortcutInfo(shortcutIntent, caption, icon);
4394 }
4395
4396 public void startDrag(View dragView, ItemInfo dragInfo, DragSource source) {
4397 dragView.setTag(dragInfo);
4398 mWorkspace.onDragStartedWithItem(dragView);
4399 mWorkspace.beginDragShared(dragView, source);
4400 }
4401
Winson Chung80baf5a2010-08-09 16:03:15 -07004402 /**
Joe Onoratobe386092009-11-17 17:32:16 -08004403 * Prints out out state for debugging.
4404 */
4405 public void dumpState() {
Daniel Sandler325dc232013-06-05 22:57:57 -04004406 Log.d(TAG, "BEGIN launcher3 dump state for launcher " + this);
Joe Onorato39bfc132009-11-18 17:22:01 -08004407 Log.d(TAG, "mSavedState=" + mSavedState);
Joe Onorato39bfc132009-11-18 17:22:01 -08004408 Log.d(TAG, "mWorkspaceLoading=" + mWorkspaceLoading);
4409 Log.d(TAG, "mRestoring=" + mRestoring);
4410 Log.d(TAG, "mWaitingForResult=" + mWaitingForResult);
4411 Log.d(TAG, "mSavedInstanceState=" + mSavedInstanceState);
Brad Fitzpatrick319226a2010-09-01 13:45:16 -07004412 Log.d(TAG, "sFolders.size=" + sFolders.size());
Joe Onoratobe386092009-11-17 17:32:16 -08004413 mModel.dumpState();
Winson Chungf0ea4d32011-06-06 14:27:16 -07004414
Winson Chung785d2eb2011-04-14 16:08:02 -07004415 if (mAppsCustomizeContent != null) {
4416 mAppsCustomizeContent.dumpState();
4417 }
Daniel Sandler325dc232013-06-05 22:57:57 -04004418 Log.d(TAG, "END launcher3 dump state");
Joe Onoratobe386092009-11-17 17:32:16 -08004419 }
Adam Cohen16d7ffc2011-10-05 17:49:14 -07004420
4421 @Override
4422 public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) {
4423 super.dump(prefix, fd, writer, args);
Adam Cohen4caf2982013-08-20 18:54:31 -07004424 synchronized (sDumpLogs) {
4425 writer.println(" ");
4426 writer.println("Debug logs: ");
4427 for (int i = 0; i < sDumpLogs.size(); i++) {
4428 writer.println(" " + sDumpLogs.get(i));
4429 }
Adam Cohen16d7ffc2011-10-05 17:49:14 -07004430 }
4431 }
Adam Cohen487f7dd2012-06-28 18:12:10 -07004432
4433 public static void dumpDebugLogsToConsole() {
Winson Chungede41292013-09-19 16:27:36 -07004434 if (DEBUG_DUMP_LOG) {
4435 synchronized (sDumpLogs) {
4436 Log.d(TAG, "");
4437 Log.d(TAG, "*********************");
4438 Log.d(TAG, "Launcher debug logs: ");
4439 for (int i = 0; i < sDumpLogs.size(); i++) {
4440 Log.d(TAG, " " + sDumpLogs.get(i));
4441 }
4442 Log.d(TAG, "*********************");
4443 Log.d(TAG, "");
Adam Cohen4caf2982013-08-20 18:54:31 -07004444 }
Adam Cohen487f7dd2012-06-28 18:12:10 -07004445 }
Adam Cohen4caf2982013-08-20 18:54:31 -07004446 }
4447
4448 public static void addDumpLog(String tag, String log, boolean debugLog) {
Dan Sandler295ae182013-12-10 16:05:47 -05004449 addDumpLog(tag, log, null, debugLog);
4450 }
4451
4452 public static void addDumpLog(String tag, String log, Exception e, boolean debugLog) {
Adam Cohen4caf2982013-08-20 18:54:31 -07004453 if (debugLog) {
Dan Sandler295ae182013-12-10 16:05:47 -05004454 if (e != null) {
4455 Log.d(tag, log, e);
4456 } else {
4457 Log.d(tag, log);
4458 }
Adam Cohen4caf2982013-08-20 18:54:31 -07004459 }
Winson Chungede41292013-09-19 16:27:36 -07004460 if (DEBUG_DUMP_LOG) {
4461 sDateStamp.setTime(System.currentTimeMillis());
4462 synchronized (sDumpLogs) {
Dan Sandler295ae182013-12-10 16:05:47 -05004463 sDumpLogs.add(sDateFormat.format(sDateStamp) + ": " + tag + ", " + log
4464 + (e == null ? "" : (", Exception: " + e)));
Adam Cohen4caf2982013-08-20 18:54:31 -07004465 }
Winson Chungede41292013-09-19 16:27:36 -07004466 }
Adam Cohen4caf2982013-08-20 18:54:31 -07004467 }
4468
Winson Chungede41292013-09-19 16:27:36 -07004469 public void dumpLogsToLocalData() {
4470 if (DEBUG_DUMP_LOG) {
Michael Jurka43467462013-11-14 12:03:58 +01004471 new AsyncTask<Void, Void, Void>() {
4472 public Void doInBackground(Void ... args) {
Winson Chungede41292013-09-19 16:27:36 -07004473 boolean success = false;
4474 sDateStamp.setTime(sRunStart);
4475 String FILENAME = sDateStamp.getMonth() + "-"
4476 + sDateStamp.getDay() + "_"
4477 + sDateStamp.getHours() + "-"
4478 + sDateStamp.getMinutes() + "_"
4479 + sDateStamp.getSeconds() + ".txt";
4480
4481 FileOutputStream fos = null;
4482 File outFile = null;
4483 try {
4484 outFile = new File(getFilesDir(), FILENAME);
4485 outFile.createNewFile();
4486 fos = new FileOutputStream(outFile);
4487 } catch (Exception e) {
4488 e.printStackTrace();
4489 }
4490 if (fos != null) {
4491 PrintWriter writer = new PrintWriter(fos);
4492
4493 writer.println(" ");
4494 writer.println("Debug logs: ");
4495 synchronized (sDumpLogs) {
4496 for (int i = 0; i < sDumpLogs.size(); i++) {
4497 writer.println(" " + sDumpLogs.get(i));
4498 }
4499 }
4500 writer.close();
4501 }
4502 try {
4503 if (fos != null) {
4504 fos.close();
4505 success = true;
4506 }
4507 } catch (IOException e) {
4508 e.printStackTrace();
4509 }
Michael Jurka43467462013-11-14 12:03:58 +01004510 return null;
Winson Chungede41292013-09-19 16:27:36 -07004511 }
Michael Jurka43467462013-11-14 12:03:58 +01004512 }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, (Void) null);
Adam Cohen4caf2982013-08-20 18:54:31 -07004513 }
Adam Cohen487f7dd2012-06-28 18:12:10 -07004514 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08004515}
Michael Jurka2763be32011-02-24 11:19:57 -08004516
Michael Jurkaabded662011-03-04 12:06:57 -08004517interface LauncherTransitionable {
Michael Jurka2a4b1a82011-12-07 14:00:02 -08004518 View getContent();
Michael Jurkaa35e35a2012-04-26 15:04:28 -07004519 void onLauncherTransitionPrepare(Launcher l, boolean animated, boolean toWorkspace);
Michael Jurkabed61d22012-02-14 22:51:29 -08004520 void onLauncherTransitionStart(Launcher l, boolean animated, boolean toWorkspace);
Winson Chung70442722012-02-10 15:43:22 -08004521 void onLauncherTransitionStep(Launcher l, float t);
Michael Jurkabed61d22012-02-14 22:51:29 -08004522 void onLauncherTransitionEnd(Launcher l, boolean animated, boolean toWorkspace);
Michael Jurka2763be32011-02-24 11:19:57 -08004523}
Dan Sandlerd5024042014-01-09 15:01:33 -05004524
4525interface DebugIntents {
4526 static final String DELETE_DATABASE = "com.android.launcher3.action.DELETE_DATABASE";
4527 static final String MIGRATE_DATABASE = "com.android.launcher3.action.MIGRATE_DATABASE";
Adam Cohen8b5b05b2014-01-10 21:42:39 +00004528}