blob: 7c85bb73965c594b46c7602e708ced87fe2e1068 [file] [log] [blame]
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Daniel Sandler325dc232013-06-05 22:57:57 -040017package com.android.launcher3;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080018
Sunny Goyalf8d56fc2018-01-31 15:18:11 -080019import static android.content.pm.ActivityInfo.CONFIG_ORIENTATION;
20import static android.content.pm.ActivityInfo.CONFIG_SCREEN_SIZE;
vadimt00d42552018-12-11 17:59:36 -080021
Pinyao Tinga74b63a2019-07-17 23:26:06 -070022import static com.android.launcher3.AbstractFloatingView.TYPE_ALL;
23import static com.android.launcher3.AbstractFloatingView.TYPE_REBIND_SAFE;
Tony Wickham6a71a5b2018-08-21 11:40:23 -070024import static com.android.launcher3.AbstractFloatingView.TYPE_SNACKBAR;
Sunny Goyal4c7f2152017-10-17 17:17:16 -070025import static com.android.launcher3.LauncherAnimUtils.SPRING_LOADED_EXIT_DELAY;
Sunny Goyal3e3f44c2017-10-23 17:14:52 -070026import static com.android.launcher3.LauncherState.ALL_APPS;
27import static com.android.launcher3.LauncherState.NORMAL;
Govinda Wassermanc06e1512019-04-09 09:56:53 -040028import static com.android.launcher3.LauncherState.OVERVIEW;
29import static com.android.launcher3.LauncherState.OVERVIEW_PEEK;
Sunny Goyalb1d7de22019-09-06 10:36:54 -070030import static com.android.launcher3.Utilities.postAsyncCallback;
Sunny Goyal6001ea22018-05-10 16:31:00 -070031import static com.android.launcher3.dragndrop.DragLayer.ALPHA_INDEX_LAUNCHER_LOAD;
Sunny Goyalaeb16432017-10-16 11:46:41 -070032import static com.android.launcher3.logging.LoggerUtils.newContainerTarget;
Hyunyoung Song46d07f72018-05-22 15:41:25 -070033import static com.android.launcher3.logging.LoggerUtils.newTarget;
Sunny Goyal3a1eadd2019-10-23 17:44:27 -070034import static com.android.launcher3.popup.SystemShortcut.APP_INFO;
Sunny Goyal3a1eadd2019-10-23 17:44:27 -070035import static com.android.launcher3.popup.SystemShortcut.INSTALL;
36import static com.android.launcher3.popup.SystemShortcut.WIDGETS;
Sunny Goyalbe8c3402019-05-22 15:17:52 -070037import static com.android.launcher3.states.RotationHelper.REQUEST_NONE;
Sunny Goyal326403e2017-10-02 12:45:10 -070038
Gilles Debunnedd6c9922010-10-25 11:23:41 -070039import android.animation.Animator;
Sunny Goyal6001ea22018-05-10 16:31:00 -070040import android.animation.AnimatorListenerAdapter;
Gilles Debunnedd6c9922010-10-25 11:23:41 -070041import android.animation.AnimatorSet;
Sunny Goyal6001ea22018-05-10 16:31:00 -070042import android.animation.ObjectAnimator;
Gilles Debunnedd6c9922010-10-25 11:23:41 -070043import android.animation.ValueAnimator;
Adam Cohen0b395352014-06-09 22:54:36 +000044import android.annotation.TargetApi;
Tony Wickham005df0b2018-02-13 11:28:12 -080045import android.app.ActivityOptions;
Adam Cohen0cf2a7c2011-11-08 15:07:01 -080046import android.appwidget.AppWidgetHostView;
Michael Jurkaaf442092010-06-10 17:01:57 -070047import android.appwidget.AppWidgetManager;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080048import android.content.ActivityNotFoundException;
Joe Onorato2ca0ae72009-11-10 13:14:13 -080049import android.content.BroadcastReceiver;
Michael Jurkae326f182011-11-21 14:05:46 -080050import android.content.ComponentCallbacks2;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080051import android.content.Context;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080052import android.content.Intent;
Winson Chungf0ea4d32011-06-06 14:27:16 -070053import android.content.IntentFilter;
Adam Cohen173f7112015-03-27 15:14:00 -070054import android.content.IntentSender;
Winson Chung82f55532011-08-09 14:14:23 -070055import android.content.SharedPreferences;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080056import android.content.pm.PackageManager;
Sunny Goyalf8d56fc2018-01-31 15:18:11 -080057import android.content.res.Configuration;
Adam Cohen3f9c9712014-10-31 11:48:25 -070058import android.database.sqlite.SQLiteDatabase;
Sunny Goyal59d086c2018-05-07 17:31:40 -070059import android.graphics.Point;
Sunny Goyalae6e3182019-04-30 12:04:37 -070060import android.graphics.Rect;
Adam Cohen0f668f32014-09-08 19:54:17 +020061import android.os.Build;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080062import android.os.Bundle;
Sunny Goyal210e1742019-10-17 12:05:38 -070063import android.os.CancellationSignal;
Hyunyoung Songbd6fba92018-05-16 15:54:31 -070064import android.os.Handler;
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -070065import android.os.Parcelable;
Sunny Goyal7c74e4a2016-12-15 15:53:17 -080066import android.os.Process;
Winson Chunga2413752012-04-03 14:22:34 -070067import android.os.StrictMode;
Michael Jurkaa33411c2012-06-14 16:18:21 -070068import android.text.TextUtils;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080069import android.text.method.TextKeyListener;
Joe Onorato7c312c12009-08-13 21:36:53 -070070import android.util.Log;
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -070071import android.util.SparseArray;
Sunny Goyal59d086c2018-05-07 17:31:40 -070072import android.view.Display;
Adam Cohen96d30a12013-07-16 18:13:21 -070073import android.view.KeyEvent;
Sunny Goyal66b24572016-09-21 15:57:55 -070074import android.view.KeyboardShortcutGroup;
75import android.view.KeyboardShortcutInfo;
Sunny Goyal9b29ca52017-02-17 10:39:44 -080076import android.view.LayoutInflater;
Adam Cohen96d30a12013-07-16 18:13:21 -070077import android.view.Menu;
vadimt9af34a72020-01-21 11:19:13 -080078import android.view.MotionEvent;
Adam Cohen96d30a12013-07-16 18:13:21 -070079import android.view.View;
Adam Cohen96d30a12013-07-16 18:13:21 -070080import android.view.ViewGroup;
Svetoslav Ganov815ba2d2011-01-07 14:55:17 -080081import android.view.accessibility.AccessibilityEvent;
Sunny Goyal5a1f53b2015-05-27 10:24:24 -070082import android.view.animation.OvershootInterpolator;
Adam Cohen96d30a12013-07-16 18:13:21 -070083import android.widget.Toast;
Sunny Goyala1d1bf32015-06-26 13:24:53 -070084
Sunny Goyal11a50742019-08-07 09:24:26 -070085import androidx.annotation.Nullable;
Pinyao Tingc9074272019-11-11 11:51:44 -080086import androidx.annotation.StringRes;
Sunny Goyalb1d7de22019-09-06 10:36:54 -070087import androidx.annotation.VisibleForTesting;
Sunny Goyal11a50742019-08-07 09:24:26 -070088
Sunny Goyal651077b2014-06-30 14:15:31 -070089import com.android.launcher3.DropTarget.DragObject;
Sunny Goyal210e1742019-10-17 12:05:38 -070090import com.android.launcher3.LauncherState.ScaleAndTranslation;
91import com.android.launcher3.LauncherStateManager.StateHandler;
Sunny Goyalae502842016-06-17 08:43:56 -070092import com.android.launcher3.accessibility.LauncherAccessibilityDelegate;
Winson Chung5f4e0fd2015-05-22 11:12:27 -070093import com.android.launcher3.allapps.AllAppsContainerView;
vadimtd4c90e12019-06-04 13:59:43 -070094import com.android.launcher3.allapps.AllAppsStore;
Hyunyoung Song645764e2016-06-06 14:19:02 -070095import com.android.launcher3.allapps.AllAppsTransitionController;
Sunny Goyal7ede6112017-12-05 15:11:21 -080096import com.android.launcher3.allapps.DiscoveryBounce;
Sunny Goyalf0b6db72018-08-13 16:10:14 -070097import com.android.launcher3.anim.PropertyListBuilder;
Tony Wickhame0c33232016-02-08 11:37:04 -080098import com.android.launcher3.config.FeatureFlags;
vadimt00d42552018-12-11 17:59:36 -080099import com.android.launcher3.dot.DotInfo;
Vadim Tryshevfedca432015-08-19 17:55:02 -0700100import com.android.launcher3.dragndrop.DragController;
101import com.android.launcher3.dragndrop.DragLayer;
102import com.android.launcher3.dragndrop.DragView;
Samuel Fufa28c3e452020-02-08 16:07:16 -0800103import com.android.launcher3.folder.Folder;
Sunny Goyal11a50742019-08-07 09:24:26 -0700104import com.android.launcher3.folder.FolderGridOrganizer;
Sunny Goyal26119432016-02-18 22:09:23 +0000105import com.android.launcher3.folder.FolderIcon;
Sunny Goyalae6e3182019-04-30 12:04:37 -0700106import com.android.launcher3.graphics.RotationMode;
Sunny Goyalf840f102018-09-21 14:41:05 -0700107import com.android.launcher3.icons.IconCache;
Sunny Goyal66b24572016-09-21 15:57:55 -0700108import com.android.launcher3.keyboard.CustomActionsPopup;
Sunny Goyal3333b0c2016-05-09 20:43:21 -0700109import com.android.launcher3.keyboard.ViewGroupFocusHelper;
Sunny Goyala7ce1662016-05-31 15:01:35 -0700110import com.android.launcher3.logging.FileLog;
Hyunyoung Songfc007472018-10-25 14:09:50 -0700111import com.android.launcher3.logging.StatsLogUtils;
Hyunyoung Songaa953652016-04-19 18:30:24 -0700112import com.android.launcher3.logging.UserEventDispatcher;
Hyunyoung Song46d07f72018-05-22 15:41:25 -0700113import com.android.launcher3.logging.UserEventDispatcher.UserEventDelegate;
Sunny Goyal369212a2019-03-26 15:03:57 -0700114import com.android.launcher3.model.AppLaunchTracker;
Sunny Goyal87dcde62019-07-17 20:35:56 -0700115import com.android.launcher3.model.BgDataModel.Callbacks;
Sunny Goyala535ae42017-02-27 10:07:13 -0800116import com.android.launcher3.model.ModelWriter;
Sunny Goyala535ae42017-02-27 10:07:13 -0800117import com.android.launcher3.notification.NotificationListener;
Sunny Goyale7b00122019-10-02 16:13:34 -0700118import com.android.launcher3.pm.PinRequestHelper;
Tony Wickham540913e2017-01-23 11:47:51 -0800119import com.android.launcher3.popup.PopupContainerWithArrow;
Sunny Goyala535ae42017-02-27 10:07:13 -0800120import com.android.launcher3.popup.PopupDataProvider;
Sunny Goyal3a1eadd2019-10-23 17:44:27 -0700121import com.android.launcher3.popup.SystemShortcut;
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700122import com.android.launcher3.qsb.QsbContainerView;
Sunny Goyal623eddd2018-03-02 12:24:41 -0800123import com.android.launcher3.states.RotationHelper;
vadimt9af34a72020-01-21 11:19:13 -0800124import com.android.launcher3.testing.TestLogging;
vadimtbc5d7e62019-12-09 13:53:05 -0800125import com.android.launcher3.testing.TestProtocol;
Sunny Goyal210e1742019-10-17 12:05:38 -0700126import com.android.launcher3.touch.AllAppsSwipeController;
Sunny Goyal8a2a63b2018-03-06 22:15:18 -0800127import com.android.launcher3.touch.ItemClickHandler;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700128import com.android.launcher3.uioverrides.plugins.PluginManagerWrapper;
Hyunyoung Song46d07f72018-05-22 15:41:25 -0700129import com.android.launcher3.userevent.nano.LauncherLogProto;
Sunny Goyal6c46a6d2016-11-23 02:24:32 +0530130import com.android.launcher3.userevent.nano.LauncherLogProto.Action;
131import com.android.launcher3.userevent.nano.LauncherLogProto.ContainerType;
Sunny Goyalaeb16432017-10-16 11:46:41 -0700132import com.android.launcher3.userevent.nano.LauncherLogProto.Target;
Sunny Goyal2100c782016-08-22 16:00:03 -0700133import com.android.launcher3.util.ActivityResultInfo;
Sunny Goyale84c5b82019-09-26 17:05:31 -0700134import com.android.launcher3.util.ActivityTracker;
Winson Chung6b1c73f2015-06-18 11:38:42 -0700135import com.android.launcher3.util.ComponentKey;
Sunny Goyalefb7e842018-10-04 15:11:00 -0700136import com.android.launcher3.util.IntArray;
Sunny Goyald3b87ef2016-07-28 12:11:54 -0700137import com.android.launcher3.util.ItemInfoMatcher;
Sunny Goyal6001ea22018-05-10 16:31:00 -0700138import com.android.launcher3.util.MultiValueAlpha;
139import com.android.launcher3.util.MultiValueAlpha.AlphaProperty;
Sunny Goyal04cc3a72016-05-17 10:32:43 -0700140import com.android.launcher3.util.PackageManagerHelper;
Tony Wickham010d2552017-01-20 08:15:28 -0800141import com.android.launcher3.util.PackageUserKey;
Sunny Goyal2100c782016-08-22 16:00:03 -0700142import com.android.launcher3.util.PendingRequestArgs;
Pinyao Ting49a3e692019-07-26 12:28:38 -0700143import com.android.launcher3.util.ShortcutUtil;
Sunny Goyal8392c822017-06-20 10:03:56 -0700144import com.android.launcher3.util.SystemUiController;
Mario Bertschlera6936942017-05-31 14:48:19 -0700145import com.android.launcher3.util.Themes;
Adam Cohen091440a2015-03-18 14:16:05 -0700146import com.android.launcher3.util.Thunk;
Sunny Goyal210e1742019-10-17 12:05:38 -0700147import com.android.launcher3.util.TouchController;
Sunny Goyalfca6bc92017-09-28 16:28:34 -0700148import com.android.launcher3.util.TraceHelper;
Sunny Goyal326403e2017-10-02 12:45:10 -0700149import com.android.launcher3.util.UiThreadHelper;
Sunny Goyal527c7d32015-08-28 15:19:36 -0700150import com.android.launcher3.util.ViewOnDrawExecutor;
Sunny Goyalab770a12018-11-14 15:17:26 -0800151import com.android.launcher3.views.ActivityContext;
Sunny Goyal7c7be8c2018-03-07 19:58:07 -0800152import com.android.launcher3.views.OptionsPopupView;
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400153import com.android.launcher3.views.ScrimView;
Sunny Goyal29947f02017-12-18 13:49:44 -0800154import com.android.launcher3.widget.LauncherAppWidgetHostView;
Sunny Goyal782f0c92017-01-19 10:27:54 -0800155import com.android.launcher3.widget.PendingAddShortcutInfo;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700156import com.android.launcher3.widget.PendingAddWidgetInfo;
Sunny Goyal29947f02017-12-18 13:49:44 -0800157import com.android.launcher3.widget.PendingAppWidgetHostView;
Sunny Goyal04a324a2017-01-20 21:08:59 -0800158import com.android.launcher3.widget.WidgetAddFlowHandler;
Hyunyoung Songb99ff3e2015-04-23 15:17:50 -0700159import com.android.launcher3.widget.WidgetHostViewLoader;
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -0700160import com.android.launcher3.widget.WidgetListRowEntry;
Sunny Goyal337c81f2019-12-10 12:19:13 -0800161import com.android.launcher3.widget.WidgetManagerHelper;
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -0700162import com.android.launcher3.widget.WidgetsFullSheet;
Pinyao Tingc7a6c292019-08-26 14:36:02 -0700163import com.android.launcher3.widget.custom.CustomWidgetManager;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700164import com.android.systemui.plugins.OverlayPlugin;
165import com.android.systemui.plugins.PluginListener;
166import com.android.systemui.plugins.shared.LauncherExterns;
167import com.android.systemui.plugins.shared.LauncherOverlayManager;
168import com.android.systemui.plugins.shared.LauncherOverlayManager.LauncherOverlay;
169import com.android.systemui.plugins.shared.LauncherOverlayManager.LauncherOverlayCallbacks;
Adam Cohen6c5891a2014-07-09 23:53:15 -0700170
Adam Cohen16d7ffc2011-10-05 17:49:14 -0700171import java.io.FileDescriptor;
Adam Cohen16d7ffc2011-10-05 17:49:14 -0700172import java.io.PrintWriter;
Adam Cohenc0dcf592011-06-01 15:30:43 -0700173import java.util.ArrayList;
Winson Chungf0c6ae02012-03-21 16:10:31 -0700174import java.util.Collection;
Zak Cohen658c67a2018-10-19 14:21:05 -0700175import java.util.HashMap;
Sunny Goyal4390ace2014-10-13 11:33:11 -0700176import java.util.HashSet;
Michael Jurkad7c28052012-04-27 15:43:36 -0700177import java.util.List;
Sunny Goyalaae6fbb2019-01-31 16:05:58 -0800178import java.util.function.Predicate;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700179import java.util.function.Supplier;
Sunny Goyal3a1eadd2019-10-23 17:44:27 -0700180import java.util.stream.Stream;
Jon Mirandaf5197fc2019-09-04 16:55:41 -0700181
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800182/**
183 * Default launcher application.
184 */
Hyunyoung Song46d07f72018-05-22 15:41:25 -0700185public class Launcher extends BaseDraggingActivity implements LauncherExterns,
Sunny Goyal01615a62019-09-20 12:00:07 -0700186 Callbacks, UserEventDelegate,
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700187 InvariantDeviceProfile.OnIDPChangeListener, PluginListener<OverlayPlugin> {
Vadim Tryshevfedca432015-08-19 17:55:02 -0700188 public static final String TAG = "Launcher";
Sunny Goyale84c5b82019-09-26 17:05:31 -0700189
190 public static final ActivityTracker<Launcher> ACTIVITY_TRACKER = new ActivityTracker<>();
191
Sunny Goyal2bba4c32015-05-18 15:42:48 -0700192 static final boolean LOGD = false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800193
Winson Chunga2413752012-04-03 14:22:34 -0700194 static final boolean DEBUG_STRICT_MODE = false;
Romain Guy6fefcf12009-06-11 13:07:43 -0700195
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800196 private static final int REQUEST_CREATE_SHORTCUT = 1;
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700197 private static final int REQUEST_CREATE_APPWIDGET = 5;
Jon Mirandac476d6e2017-05-04 16:30:01 -0700198
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700199 private static final int REQUEST_PICK_APPWIDGET = 9;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800200
Michael Jurka8b805b12012-04-18 14:23:14 -0700201 private static final int REQUEST_BIND_APPWIDGET = 11;
Sunny Goyal8a2a63b2018-03-06 22:15:18 -0800202 public static final int REQUEST_BIND_PENDING_APPWIDGET = 12;
203 public static final int REQUEST_RECONFIGURE_APPWIDGET = 13;
Michael Jurka8b805b12012-04-18 14:23:14 -0700204
Jon Mirandac476d6e2017-05-04 16:30:01 -0700205 private static final int REQUEST_PERMISSION_CALL_PHONE = 14;
Sunny Goyal28c6b962015-10-12 11:42:05 -0700206
Sunny Goyal5a1f53b2015-05-27 10:24:24 -0700207 private static final float BOUNCE_ANIMATION_TENSION = 1.3f;
208
Mathew Inwood876a8462013-06-14 14:12:41 +0100209 /**
210 * IntentStarter uses request codes starting with this. This must be greater than all activity
211 * request codes used internally.
212 */
213 protected static final int REQUEST_LAST = 100;
214
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800215 // Type: int
216 private static final String RUNTIME_STATE_CURRENT_SCREEN = "launcher.current_screen";
Michael Jurka883f55b2010-10-21 15:47:14 -0700217 // Type: int
218 private static final String RUNTIME_STATE = "launcher.state";
Sunny Goyal2100c782016-08-22 16:00:03 -0700219 // Type: PendingRequestArgs
220 private static final String RUNTIME_STATE_PENDING_REQUEST_ARGS = "launcher.request_args";
Sunny Goyaldedda052019-05-14 15:23:48 -0700221 // Type: int
222 private static final String RUNTIME_STATE_PENDING_REQUEST_CODE = "launcher.request_code";
Sunny Goyal2100c782016-08-22 16:00:03 -0700223 // Type: ActivityResultInfo
224 private static final String RUNTIME_STATE_PENDING_ACTIVITY_RESULT = "launcher.activity_result";
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -0700225 // Type: SparseArray<Parcelable>
226 private static final String RUNTIME_STATE_WIDGET_PANEL = "launcher.widget_panel";
Sunny Goyal17c72fb2019-10-14 14:06:38 -0700227
vadimt00d42552018-12-11 17:59:36 -0800228 public static final String ON_CREATE_EVT = "Launcher.onCreate";
Sunny Goyal17c72fb2019-10-14 14:06:38 -0700229 public static final String ON_START_EVT = "Launcher.onStart";
230 public static final String ON_RESUME_EVT = "Launcher.onResume";
231 public static final String ON_NEW_INTENT_EVT = "Launcher.onNewIntent";
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800232
Sunny Goyal3e3f44c2017-10-23 17:14:52 -0700233 private LauncherStateManager mStateManager;
Patrick Dubroy6b509c12010-08-23 15:08:16 -0700234
Adam Cohenad4e15c2013-10-17 16:21:35 -0700235 private static final int ON_ACTIVITY_RESULT_ANIMATION_DELAY = 500;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800236
Winson Chunga2413752012-04-03 14:22:34 -0700237 // How long to wait before the new-shortcut animation automatically pans the workspace
Jon Mirandaf5197fc2019-09-04 16:55:41 -0700238 @VisibleForTesting public static final int NEW_APPS_PAGE_MOVE_DELAY = 500;
Rajeev Kumar43c0f582017-06-23 15:34:55 -0700239 private static final int NEW_APPS_ANIMATION_INACTIVE_TIMEOUT_SECONDS = 5;
Jon Mirandaf5197fc2019-09-04 16:55:41 -0700240 @Thunk @VisibleForTesting public static final int NEW_APPS_ANIMATION_DELAY = 500;
Winson Chunga2413752012-04-03 14:22:34 -0700241
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400242 private static final int APPS_VIEW_ALPHA_CHANNEL_INDEX = 1;
243 private static final int SCRIM_VIEW_ALPHA_CHANNEL_INDEX = 0;
244
Jon Miranda54441f52018-01-24 15:38:25 -0800245 private LauncherAppTransitionManager mAppTransitionManager;
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800246 private Configuration mOldConfig;
Jon Miranda54441f52018-01-24 15:38:25 -0800247
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700248 @Thunk
249 Workspace mWorkspace;
Craig Mautner360310b2012-10-26 15:13:08 -0700250 private View mLauncherView;
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700251 @Thunk
252 DragLayer mDragLayer;
Michael Jurkab737ee62011-11-15 15:57:22 -0800253 private DragController mDragController;
Sunny Goyal322d5562015-06-25 19:35:49 -0700254
Sunny Goyal337c81f2019-12-10 12:19:13 -0800255 private WidgetManagerHelper mAppWidgetManager;
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700256 private LauncherAppWidgetHost mAppWidgetHost;
Romain Guycbb89e42009-06-08 15:52:54 -0700257
Rajeev Kumar43c0f582017-06-23 15:34:55 -0700258 private final int[] mTmpAddItemCellCoordinates = new int[2];
Michael Jurka0280c3b2010-09-17 15:00:07 -0700259
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700260 @Thunk
261 Hotseat mHotseat;
Adam Cohenf358a4b2013-07-23 16:47:31 -0700262
Sunny Goyal47328fd2016-05-25 18:56:41 -0700263 private DropTargetBar mDropTargetBar;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700264
265 // Main container view for the all apps screen.
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700266 @Thunk
267 AllAppsContainerView mAppsView;
Hyunyoung Song645764e2016-06-06 14:19:02 -0700268 AllAppsTransitionController mAllAppsController;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700269
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400270 // Scrim view for the all apps and overview state.
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700271 @Thunk
272 ScrimView mScrimView;
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400273
Winson Chung8ae41982017-11-10 11:42:13 -0800274 // UI and state for the overview panel
Sunny Goyal7c7be8c2018-03-07 19:58:07 -0800275 private View mOverviewPanel;
Sreyas321bfae2020-02-21 17:53:02 -0800276 private View mActionsView;
Winson Chung8ae41982017-11-10 11:42:13 -0800277
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700278 @Thunk
279 boolean mWorkspaceLoading = true;
Joe Onorato9c1289c2009-08-17 11:03:03 -0400280
Winson Chung0b70cd42019-06-17 22:34:33 -0700281 private ArrayList<OnResumeCallback> mOnResumeCallbacks = new ArrayList<>();
Sunny Goyal3dce5f32017-10-05 11:40:05 -0700282
Winson Chungc9bf6d42019-10-04 15:33:18 -0700283 // Used to notify when an activity launch has been deferred because launcher is not yet resumed
284 // TODO: See if we can remove this later
285 private Runnable mOnDeferredActivityLaunchCallback;
286
Sunny Goyal527c7d32015-08-28 15:19:36 -0700287 private ViewOnDrawExecutor mPendingExecutor;
Michael Jurka7607c2f2013-04-03 14:33:19 -0700288
Joe Onorato9c1289c2009-08-17 11:03:03 -0400289 private LauncherModel mModel;
Sunny Goyal43bf11d2017-02-02 13:52:53 -0800290 private ModelWriter mModelWriter;
Joe Onorato0589f0f2010-02-08 13:44:00 -0800291 private IconCache mIconCache;
Sunny Goyalae502842016-06-17 08:43:56 -0700292 private LauncherAccessibilityDelegate mAccessibilityDelegate;
Joe Onorato9c1289c2009-08-17 11:03:03 -0400293
Tony Wickham010d2552017-01-20 08:15:28 -0800294 private PopupDataProvider mPopupDataProvider;
Tony Wickhambfbf7f92016-05-19 11:19:39 -0700295
Sunny Goyalf4aceab2017-12-06 16:16:31 -0800296 private int mSynchronouslyBoundPage = PagedView.INVALID_PAGE;
Sunny Goyala7a5bf32020-01-05 15:35:29 +0530297 private int mPageToBindSynchronously = PagedView.INVALID_PAGE;
Adam Cohen1462de32012-07-24 22:34:36 -0700298
Winson Chung46353de2012-02-16 14:05:10 -0800299 // We only want to get the SharedPreferences once since it does an FS stat each time we get
300 // it from the context.
301 private SharedPreferences mSharedPrefs;
302
Sunny Goyal2100c782016-08-22 16:00:03 -0700303 // Activity result which needs to be processed after workspace has loaded.
304 private ActivityResultInfo mPendingActivityResult;
305 /**
306 * Holds extra information required to handle a result from an external call, like
307 * {@link #startActivityForResult(Intent, int)} or {@link #requestPermissions(String[], int)}
308 */
309 private PendingRequestArgs mPendingRequestArgs;
Sunny Goyaldedda052019-05-14 15:23:48 -0700310 // Request id for any pending activity result
Sunny Goyal210e1742019-10-17 12:05:38 -0700311 protected int mPendingActivityRequestCode = -1;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800312
Tracy Zhou4d7b2442019-12-09 13:42:57 -0800313 private ViewGroupFocusHelper mFocusHandler;
Hyunyoung Song7fb3ccc2017-10-17 15:39:46 -0700314
Sunny Goyal623eddd2018-03-02 12:24:41 -0800315 private RotationHelper mRotationHelper;
Sunny Goyal7779d622015-06-11 16:18:39 -0700316
Sunny Goyal2db53422019-03-01 16:06:12 -0800317 final Handler mHandler = new Handler();
Sunny Goyala002c6c2019-02-12 16:20:10 -0800318 private final Runnable mHandleDeferredResume = this::handleDeferredResume;
Sunny Goyale9c6f4c2019-05-30 11:35:25 -0700319 private boolean mDeferredResumePending;
Hyunyoung Songbd6fba92018-05-16 15:54:31 -0700320
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400321 private float mCurrentAssistantVisibility = 0f;
322
Sunny Goyalae6e3182019-04-30 12:04:37 -0700323 private DeviceProfile mStableDeviceProfile;
324 private RotationMode mRotationMode = RotationMode.NORMAL;
325
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700326 protected LauncherOverlayManager mOverlayManager;
327 // If true, overlay callbacks are deferred
328 private boolean mDeferOverlayCallbacks;
329 private final Runnable mDeferredOverlayCallbacks = this::checkIfOverlayStillDeferred;
330
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800331 @Override
332 protected void onCreate(Bundle savedInstanceState) {
Winson Chung5cc62c72019-10-16 11:32:41 -0700333 Object traceToken = TraceHelper.INSTANCE.beginSection(ON_CREATE_EVT,
334 TraceHelper.FLAG_UI_EVENT);
Winson Chunga2413752012-04-03 14:22:34 -0700335 if (DEBUG_STRICT_MODE) {
336 StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
337 .detectDiskReads()
338 .detectDiskWrites()
339 .detectNetwork() // or .detectAll() for all detectable problems
340 .penaltyLog()
341 .build());
342 StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
343 .detectLeakedSqlLiteObjects()
344 .detectLeakedClosableObjects()
345 .penaltyLog()
346 .penaltyDeath()
347 .build());
348 }
349
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800350 super.onCreate(savedInstanceState);
Daniel Sandlere060b0b2013-06-27 21:47:55 -0400351
Sunny Goyal87f784c2017-01-11 10:48:34 -0800352 LauncherAppState app = LauncherAppState.getInstance(this);
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800353 mOldConfig = new Configuration(getResources().getConfiguration());
Sunny Goyala7a5bf32020-01-05 15:35:29 +0530354 mModel = app.getModel();
Sunny Goyal41d51a02019-05-14 09:44:34 -0700355 mRotationHelper = new RotationHelper(this);
Hyunyoung Song31971a32019-01-27 12:31:12 -0800356 InvariantDeviceProfile idp = app.getInvariantDeviceProfile();
357 initDeviceProfile(idp);
358 idp.addOnChangeListener(this);
Sunny Goyalf7258242015-10-19 16:59:07 -0700359 mSharedPrefs = Utilities.getPrefs(this);
Joe Onorato0589f0f2010-02-08 13:44:00 -0800360 mIconCache = app.getIconCache();
Sunny Goyalae502842016-06-17 08:43:56 -0700361 mAccessibilityDelegate = new LauncherAccessibilityDelegate(this);
Adam Cohen2e6da152015-05-06 11:42:25 -0700362
Joe Onorato41a12d22009-10-31 18:30:00 -0400363 mDragController = new DragController(this);
Hyunyoung Song645764e2016-06-06 14:19:02 -0700364 mAllAppsController = new AllAppsTransitionController(this);
Sunny Goyalc4fa8c32017-11-07 12:23:58 -0800365 mStateManager = new LauncherStateManager(this);
Romain Guycbb89e42009-06-08 15:52:54 -0700366
Sunny Goyal337c81f2019-12-10 12:19:13 -0800367 mAppWidgetManager = new WidgetManagerHelper(this);
Samuel Fufa44043ec2019-08-26 15:00:30 -0700368 mAppWidgetHost = new LauncherAppWidgetHost(this,
369 appWidgetId -> getWorkspace().removeWidget(appWidgetId));
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700370 mAppWidgetHost.startListening();
Romain Guycbb89e42009-06-08 15:52:54 -0700371
Sunny Goyal60820d72017-05-09 12:40:11 -0700372 mLauncherView = LayoutInflater.from(this).inflate(R.layout.launcher, null);
Michael Jurka7267fa52013-09-26 15:29:57 -0700373
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800374 setupViews();
Sunny Goyal9c2b9602020-01-07 13:07:55 -0800375 mPopupDataProvider = new PopupDataProvider(this::updateNotificationDots);
Tony Wickham010d2552017-01-20 08:15:28 -0800376
Sunny Goyal90548432018-04-04 17:17:00 -0700377 mAppTransitionManager = LauncherAppTransitionManager.newInstance(this);
Winson Chung24ab40c2019-10-30 22:35:09 -0700378 mAppTransitionManager.registerRemoteAnimations();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800379
Sunny Goyale84c5b82019-09-26 17:05:31 -0700380 boolean internalStateHandled = ACTIVITY_TRACKER.handleCreate(this);
Sunny Goyald3864fa2017-11-14 15:06:36 -0800381 if (internalStateHandled) {
Sunny Goyald3864fa2017-11-14 15:06:36 -0800382 if (savedInstanceState != null) {
383 // InternalStateHandler has already set the appropriate state.
384 // We dont need to do anything.
385 savedInstanceState.remove(RUNTIME_STATE);
386 }
387 }
388 restoreState(savedInstanceState);
Sunny Goyalbbece862019-03-01 13:13:52 -0800389 mStateManager.reapplyState();
Winson Chungb63b44c2017-11-10 17:54:44 -0800390
Sunny Goyal2100c782016-08-22 16:00:03 -0700391 // We only load the page synchronously if the user rotates (or triggers a
392 // configuration change) while launcher is in the foreground
Sunny Goyala7a5bf32020-01-05 15:35:29 +0530393 int currentScreen = PagedView.INVALID_PAGE;
Sunny Goyalfe770c92016-09-27 14:38:58 -0700394 if (savedInstanceState != null) {
395 currentScreen = savedInstanceState.getInt(RUNTIME_STATE_CURRENT_SCREEN, currentScreen);
396 }
Sunny Goyala7a5bf32020-01-05 15:35:29 +0530397 mPageToBindSynchronously = currentScreen;
Sunny Goyald3864fa2017-11-14 15:06:36 -0800398
Sunny Goyala7a5bf32020-01-05 15:35:29 +0530399 if (!mModel.addCallbacksAndLoad(this)) {
Sunny Goyald3864fa2017-11-14 15:06:36 -0800400 if (!internalStateHandled) {
401 // If we are not binding synchronously, show a fade in animation when
402 // the first page bind completes.
Sunny Goyal6001ea22018-05-10 16:31:00 -0700403 mDragLayer.getAlphaProperty(ALPHA_INDEX_LAUNCHER_LOAD).setValue(0);
Sunny Goyald3864fa2017-11-14 15:06:36 -0800404 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800405 }
406
407 // For handling default keys
Sunny Goyalf4aceab2017-12-06 16:16:31 -0800408 setDefaultKeyMode(DEFAULT_KEYS_SEARCH_LOCAL);
Joe Onorato34a0e1b2009-12-14 17:44:51 -0800409
Sunny Goyal0bbd5542016-11-11 10:41:26 -0800410 setContentView(mLauncherView);
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800411 getRootView().dispatchInsets();
Mario Bertschlera6936942017-05-31 14:48:19 -0700412
Jon Miranda7fda2852017-07-19 16:07:01 -0700413 // Listen for broadcasts
Sunny Goyal5d1873a2018-05-08 11:10:44 -0700414 registerReceiver(mScreenOffReceiver, new IntentFilter(Intent.ACTION_SCREEN_OFF));
Sunny Goyala616d2b2017-06-12 13:54:01 -0700415
Sunny Goyal8392c822017-06-20 10:03:56 -0700416 getSystemUiController().updateUiState(SystemUiController.UI_STATE_BASE_WINDOW,
417 Themes.getAttrBoolean(this, R.attr.isWorkspaceDarkText));
Sunny Goyal14b32402017-07-31 10:03:28 -0700418
419 if (mLauncherCallbacks != null) {
420 mLauncherCallbacks.onCreate(savedInstanceState);
421 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700422 mOverlayManager = getDefaultOverlay();
423 PluginManagerWrapper.INSTANCE.get(this).addPluginListener(this,
424 OverlayPlugin.class, false /* allowedMultiple */);
425
Sunny Goyal623eddd2018-03-02 12:24:41 -0800426 mRotationHelper.initialize();
Sunny Goyalfca6bc92017-09-28 16:28:34 -0700427
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400428 mStateManager.addStateListener(new LauncherStateManager.StateListener() {
429 @Override
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700430 public void onStateTransitionStart(LauncherState toState) {
431 }
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400432
433 @Override
434 public void onStateTransitionComplete(LauncherState finalState) {
435 float alpha = 1f - mCurrentAssistantVisibility;
436 if (finalState == NORMAL) {
437 mAppsView.getAlphaProperty(APPS_VIEW_ALPHA_CHANNEL_INDEX).setValue(alpha);
438 } else if (finalState == OVERVIEW || finalState == OVERVIEW_PEEK) {
439 mAppsView.getAlphaProperty(APPS_VIEW_ALPHA_CHANNEL_INDEX).setValue(alpha);
440 mScrimView.getAlphaProperty(SCRIM_VIEW_ALPHA_CHANNEL_INDEX).setValue(alpha);
441 } else {
442 mAppsView.getAlphaProperty(APPS_VIEW_ALPHA_CHANNEL_INDEX).setValue(1f);
443 mScrimView.getAlphaProperty(SCRIM_VIEW_ALPHA_CHANNEL_INDEX).setValue(1f);
444 }
445 }
446 });
Sunny Goyal17c72fb2019-10-14 14:06:38 -0700447
Winson Chung5cc62c72019-10-16 11:32:41 -0700448 TraceHelper.INSTANCE.endSection(traceToken);
Adam Cohen9211d422014-10-07 18:14:53 -0700449 }
450
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700451 protected LauncherOverlayManager getDefaultOverlay() {
452 return new LauncherOverlayManager() { };
453 }
454
455 @Override
456 public void onPluginConnected(OverlayPlugin overlayManager, Context context) {
457 switchOverlay(() -> overlayManager.createOverlayManager(this, this));
458 }
459
460 @Override
461 public void onPluginDisconnected(OverlayPlugin plugin) {
462 switchOverlay(this::getDefaultOverlay);
463 }
464
465 private void switchOverlay(Supplier<LauncherOverlayManager> overlaySupplier) {
466 if (mOverlayManager != null) {
467 mOverlayManager.onActivityDestroyed(this);
468 }
469 mOverlayManager = overlaySupplier.get();
470 if (getRootView().isAttachedToWindow()) {
471 mOverlayManager.onAttachedToWindow();
472 }
473 mDeferOverlayCallbacks = true;
474 checkIfOverlayStillDeferred();
475 }
476
477 @Override
478 protected void dispatchDeviceProfileChanged() {
479 super.dispatchDeviceProfileChanged();
480 mOverlayManager.onDeviceProvideChanged();
481 }
482
Sunny Goyal7779d622015-06-11 16:18:39 -0700483 @Override
Winson Chung8eb49e02018-07-16 13:33:31 -0700484 public void onEnterAnimationComplete() {
485 super.onEnterAnimationComplete();
Sunny Goyalbe8c3402019-05-22 15:17:52 -0700486 mRotationHelper.setCurrentTransitionRequest(REQUEST_NONE);
Winson Chung8eb49e02018-07-16 13:33:31 -0700487 }
488
489 @Override
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800490 public void onConfigurationChanged(Configuration newConfig) {
491 int diff = newConfig.diff(mOldConfig);
Jon Mirandaaeb4dd02018-07-11 14:16:23 -0700492
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800493 if ((diff & (CONFIG_ORIENTATION | CONFIG_SCREEN_SIZE)) != 0) {
Sunny Goyal371ea052019-03-06 15:38:32 -0800494 onIdpChanged(mDeviceProfile.inv);
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800495 }
496
497 mOldConfig.setTo(newConfig);
498 super.onConfigurationChanged(newConfig);
499 }
500
Sunny Goyal3e195d72019-06-19 14:24:38 -0700501 public void reload() {
502 onIdpChanged(mDeviceProfile.inv);
503 }
504
Sunny Goyal41d51a02019-05-14 09:44:34 -0700505 private boolean supportsFakeLandscapeUI() {
506 return FeatureFlags.FAKE_LANDSCAPE_UI.get() && !mRotationHelper.homeScreenCanRotate();
507 }
508
Sunny Goyal605bcf32018-03-02 15:16:12 -0800509 @Override
Sunny Goyal41d51a02019-05-14 09:44:34 -0700510 public void reapplyUi() {
Tony Wickham4df42f82019-11-13 15:38:28 -0800511 reapplyUi(true /* cancelCurrentAnimation */);
512 }
513
514 public void reapplyUi(boolean cancelCurrentAnimation) {
Sunny Goyal41d51a02019-05-14 09:44:34 -0700515 if (supportsFakeLandscapeUI()) {
Sunny Goyal7a39b1b2019-05-02 13:39:16 -0700516 mRotationMode = mStableDeviceProfile == null
Sunny Goyal210e1742019-10-17 12:05:38 -0700517 ? RotationMode.NORMAL : getFakeRotationMode(mDeviceProfile);
Sunny Goyalae6e3182019-04-30 12:04:37 -0700518 }
Sunny Goyal59d086c2018-05-07 17:31:40 -0700519 getRootView().dispatchInsets();
Tony Wickham4df42f82019-11-13 15:38:28 -0800520 getStateManager().reapplyState(cancelCurrentAnimation);
Sunny Goyal59d086c2018-05-07 17:31:40 -0700521 }
522
523 @Override
Hyunyoung Song31971a32019-01-27 12:31:12 -0800524 public void onIdpChanged(int changeFlags, InvariantDeviceProfile idp) {
Sunny Goyal371ea052019-03-06 15:38:32 -0800525 onIdpChanged(idp);
526 }
527
528 private void onIdpChanged(InvariantDeviceProfile idp) {
529 mUserEventDispatcher = null;
530
Sunny Goyalc8502c12019-06-10 12:14:47 -0700531 DeviceProfile oldWallpaperProfile = getWallpaperDeviceProfile();
Hyunyoung Song31971a32019-01-27 12:31:12 -0800532 initDeviceProfile(idp);
Sunny Goyal371ea052019-03-06 15:38:32 -0800533 dispatchDeviceProfileChanged();
534 reapplyUi();
535 mDragLayer.recreateControllers();
536
Sunny Goyal76ba0a32019-06-10 11:56:11 -0700537 // Calling onSaveInstanceState ensures that static cache used by listWidgets is
538 // initialized properly.
539 onSaveInstanceState(new Bundle());
Sunny Goyalc8502c12019-06-10 12:14:47 -0700540 if (oldWallpaperProfile != getWallpaperDeviceProfile()) {
Sunny Goyala7a5bf32020-01-05 15:35:29 +0530541 mModel.rebindCallbacks();
Sunny Goyalc8502c12019-06-10 12:14:47 -0700542 }
Hyunyoung Song31971a32019-01-27 12:31:12 -0800543 }
544
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400545 public void onAssistantVisibilityChanged(float visibility) {
546 mCurrentAssistantVisibility = visibility;
547 float alpha = 1f - visibility;
548 LauncherState state = mStateManager.getState();
549 if (state == NORMAL) {
550 mAppsView.getAlphaProperty(APPS_VIEW_ALPHA_CHANNEL_INDEX).setValue(alpha);
551 } else if (state == OVERVIEW || state == OVERVIEW_PEEK) {
552 mAppsView.getAlphaProperty(APPS_VIEW_ALPHA_CHANNEL_INDEX).setValue(alpha);
553 mScrimView.getAlphaProperty(SCRIM_VIEW_ALPHA_CHANNEL_INDEX).setValue(alpha);
554 }
555 }
556
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800557 private void initDeviceProfile(InvariantDeviceProfile idp) {
558 // Load configuration-specific DeviceProfile
Sunny Goyal59d086c2018-05-07 17:31:40 -0700559 mDeviceProfile = idp.getDeviceProfile(this);
Sunny Goyal8c48d8b2019-01-25 15:10:18 -0800560 if (isInMultiWindowMode()) {
Winson Chung13c1c2c2019-09-06 11:46:19 -0700561 // Note: Calls to getSize() can't rely on our cached DefaultDisplay since it can return
562 // the app window size
Sunny Goyal59d086c2018-05-07 17:31:40 -0700563 Display display = getWindowManager().getDefaultDisplay();
564 Point mwSize = new Point();
565 display.getSize(mwSize);
566 mDeviceProfile = mDeviceProfile.getMultiWindowProfile(this, mwSize);
567 }
Sunny Goyalae6e3182019-04-30 12:04:37 -0700568
Sunny Goyalda14cf82019-05-30 10:31:09 -0700569 if (supportsFakeLandscapeUI() && mDeviceProfile.isVerticalBarLayout()) {
Sunny Goyalae6e3182019-04-30 12:04:37 -0700570 mStableDeviceProfile = mDeviceProfile.inv.portraitProfile;
Sunny Goyal210e1742019-10-17 12:05:38 -0700571 mRotationMode = getFakeRotationMode(mDeviceProfile);
Sunny Goyalae6e3182019-04-30 12:04:37 -0700572 } else {
573 mStableDeviceProfile = null;
574 mRotationMode = RotationMode.NORMAL;
575 }
576
Sunny Goyalda14cf82019-05-30 10:31:09 -0700577 mRotationHelper.updateRotationAnimation();
Sunny Goyal59d086c2018-05-07 17:31:40 -0700578 onDeviceProfileInitiated();
Sunny Goyalae6e3182019-04-30 12:04:37 -0700579 mModelWriter = mModel.getWriter(getWallpaperDeviceProfile().isVerticalBarLayout(), true);
580 }
581
582 public void updateInsets(Rect insets) {
583 mDeviceProfile.updateInsets(insets);
584 if (mStableDeviceProfile != null) {
Sunny Goyal7a39b1b2019-05-02 13:39:16 -0700585 Rect r = mStableDeviceProfile.getInsets();
586 mRotationMode.mapInsets(this, insets, r);
587 mStableDeviceProfile.updateInsets(r);
Sunny Goyalae6e3182019-04-30 12:04:37 -0700588 }
589 }
590
591 @Override
592 public RotationMode getRotationMode() {
593 return mRotationMode;
594 }
595
596 /**
597 * Device profile to be used by UI elements which are shown directly on top of the wallpaper
598 * and whose presentation is tied to the wallpaper (and physical device) and not the activity
599 * configuration.
600 */
601 @Override
602 public DeviceProfile getWallpaperDeviceProfile() {
603 return mStableDeviceProfile == null ? mDeviceProfile : mStableDeviceProfile;
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800604 }
605
Sunny Goyal623eddd2018-03-02 12:24:41 -0800606 public RotationHelper getRotationHelper() {
607 return mRotationHelper;
608 }
609
Tracy Zhou4d7b2442019-12-09 13:42:57 -0800610 public ViewGroupFocusHelper getFocusHandler() {
611 return mFocusHandler;
612 }
613
Sunny Goyal3e3f44c2017-10-23 17:14:52 -0700614 public LauncherStateManager getStateManager() {
615 return mStateManager;
Sunny Goyalbe93f262017-10-20 17:05:27 -0700616 }
617
Mario Bertschler27288382017-05-24 15:35:09 -0700618 @Override
Sunny Goyalc7b8df82017-06-27 11:11:03 -0700619 public <T extends View> T findViewById(int id) {
Sunny Goyal0bbd5542016-11-11 10:41:26 -0800620 return mLauncherView.findViewById(id);
621 }
622
Adam Cohen9211d422014-10-07 18:14:53 -0700623 private LauncherCallbacks mLauncherCallbacks;
624
Sunny Goyal32554d12015-12-03 15:31:25 -0800625 /**
626 * Call this after onCreate to set or clear overlay.
627 */
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700628 @Override
Sunny Goyal32554d12015-12-03 15:31:25 -0800629 public void setLauncherOverlay(LauncherOverlay overlay) {
630 if (overlay != null) {
631 overlay.setOverlayCallbacks(new LauncherOverlayCallbacksImpl());
632 }
633 mWorkspace.setLauncherOverlay(overlay);
634 }
635
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700636 @Override
637 public void runOnOverlayHidden(Runnable runnable) {
638 getWorkspace().runOnOverlayHidden(runnable);
639 }
640
Adam Cohen9211d422014-10-07 18:14:53 -0700641 public boolean setLauncherCallbacks(LauncherCallbacks callbacks) {
642 mLauncherCallbacks = callbacks;
643 return true;
Adam Cohenf9426d52012-06-04 17:26:21 -0700644 }
645
Hyunyoung Song3f471442015-04-08 19:01:34 -0700646 public boolean isDraggingEnabled() {
Winson Chung36a62fe2012-05-06 18:04:42 -0700647 // We prevent dragging when we are loading the workspace as it is possible to pick up a view
648 // that is subsequently removed from the workspace in startBinding().
Sunny Goyal639e9062015-08-19 19:17:06 -0700649 return !isWorkspaceLoading();
Winson Chung36a62fe2012-05-06 18:04:42 -0700650 }
651
Tony Wickham010d2552017-01-20 08:15:28 -0800652 public PopupDataProvider getPopupDataProvider() {
653 return mPopupDataProvider;
654 }
655
Sunny Goyal0b0847b2018-03-14 12:30:11 -0700656 @Override
Tony Wickhamf34bee82018-12-03 18:11:39 -0800657 public DotInfo getDotInfoForItem(ItemInfo info) {
658 return mPopupDataProvider.getDotInfoForItem(info);
Sunny Goyal0b0847b2018-03-14 12:30:11 -0700659 }
660
661 @Override
662 public void invalidateParent(ItemInfo info) {
Jon Mirandae6f3fa42019-03-04 09:14:40 -0800663 if (info.container >= 0) {
Sunny Goyal0b0847b2018-03-14 12:30:11 -0700664 View folderIcon = getWorkspace().getHomescreenIconByItemId(info.container);
Jon Mirandae6f3fa42019-03-04 09:14:40 -0800665 if (folderIcon instanceof FolderIcon && folderIcon.getTag() instanceof FolderInfo) {
Sunny Goyal11a50742019-08-07 09:24:26 -0700666 if (new FolderGridOrganizer(getDeviceProfile().inv)
667 .setFolderInfo((FolderInfo) folderIcon.getTag())
668 .isItemInPreview(info.rank)) {
Jon Mirandae6f3fa42019-03-04 09:14:40 -0800669 folderIcon.invalidate();
670 }
Sunny Goyal0b0847b2018-03-14 12:30:11 -0700671 }
672 }
673 }
674
Adam Cohenc76e1dd2013-11-14 11:09:14 +0000675 /**
Winson Chung557d6ed2011-07-08 15:34:52 -0700676 * Returns whether we should delay spring loaded mode -- for shortcuts and widgets that have
677 * a configuration step, this allows the proper animations to run after other transitions.
678 */
Sunny Goyalefb7e842018-10-04 15:11:00 -0700679 private int completeAdd(
Sunny Goyal2100c782016-08-22 16:00:03 -0700680 int requestCode, Intent intent, int appWidgetId, PendingRequestArgs info) {
Sunny Goyalefb7e842018-10-04 15:11:00 -0700681 int screenId = info.screenId;
Sunny Goyal2100c782016-08-22 16:00:03 -0700682 if (info.container == LauncherSettings.Favorites.CONTAINER_DESKTOP) {
Adam Cohen83079e42014-09-19 17:43:08 -0700683 // When the screen id represents an actual screen (as opposed to a rank) we make sure
684 // that the drop page actually exists.
Sunny Goyal2100c782016-08-22 16:00:03 -0700685 screenId = ensurePendingDropLayoutExists(info.screenId);
Adam Cohen83079e42014-09-19 17:43:08 -0700686 }
Adam Cohendb364c32014-05-20 14:23:40 -0700687
Sunny Goyal2100c782016-08-22 16:00:03 -0700688 switch (requestCode) {
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800689 case REQUEST_CREATE_SHORTCUT:
Sunny Goyalfb5096d2016-09-08 14:32:06 -0700690 completeAddShortcut(intent, info.container, screenId, info.cellX, info.cellY, info);
Pinyao Tingc9074272019-11-11 11:51:44 -0800691 announceForAccessibility(R.string.item_added_to_workspace);
Winson Chungb8472bb2011-08-05 13:49:21 -0700692 break;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800693 case REQUEST_CREATE_APPWIDGET:
Sunny Goyal2100c782016-08-22 16:00:03 -0700694 completeAddAppWidget(appWidgetId, info, null, null);
Winson Chungb8472bb2011-08-05 13:49:21 -0700695 break;
Sunny Goyalff572272014-07-23 13:58:07 -0700696 case REQUEST_RECONFIGURE_APPWIDGET:
Sunny Goyal2100c782016-08-22 16:00:03 -0700697 completeRestoreAppWidget(appWidgetId, LauncherAppWidgetInfo.RESTORE_COMPLETED);
Sunny Goyalff572272014-07-23 13:58:07 -0700698 break;
Sunny Goyald478c832016-04-01 12:04:16 -0700699 case REQUEST_BIND_PENDING_APPWIDGET: {
Sunny Goyal2100c782016-08-22 16:00:03 -0700700 int widgetId = appWidgetId;
701 LauncherAppWidgetInfo widgetInfo =
Sunny Goyald478c832016-04-01 12:04:16 -0700702 completeRestoreAppWidget(widgetId, LauncherAppWidgetInfo.FLAG_UI_NOT_READY);
Sunny Goyal2100c782016-08-22 16:00:03 -0700703 if (widgetInfo != null) {
Sunny Goyald478c832016-04-01 12:04:16 -0700704 // Since the view was just bound, also launch the configure activity if needed
705 LauncherAppWidgetProviderInfo provider = mAppWidgetManager
706 .getLauncherAppWidgetInfo(widgetId);
Sunny Goyal04a324a2017-01-20 21:08:59 -0800707 if (provider != null) {
708 new WidgetAddFlowHandler(provider)
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700709 .startConfigActivity(this, widgetInfo,
710 REQUEST_RECONFIGURE_APPWIDGET);
Sunny Goyald478c832016-04-01 12:04:16 -0700711 }
712 }
713 break;
714 }
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800715 }
Adam Cohendb364c32014-05-20 14:23:40 -0700716 return screenId;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800717 }
718
Adam Cohenc7cd2cb2014-11-17 17:45:34 -0800719 private void handleActivityResult(
Michael Jurka8b805b12012-04-18 14:23:14 -0700720 final int requestCode, final int resultCode, final Intent data) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700721 if (isWorkspaceLoading()) {
722 // process the result once the workspace has loaded.
723 mPendingActivityResult = new ActivityResultInfo(requestCode, resultCode, data);
724 return;
725 }
726 mPendingActivityResult = null;
727
Winson Chunge341d302013-08-16 14:31:00 -0700728 // Reset the startActivity waiting flag
Sunny Goyal2100c782016-08-22 16:00:03 -0700729 final PendingRequestArgs requestArgs = mPendingRequestArgs;
730 setWaitingForResult(null);
731 if (requestArgs == null) {
732 return;
733 }
734
735 final int pendingAddWidgetId = requestArgs.getWidgetId();
Winson Chunge341d302013-08-16 14:31:00 -0700736
Adam Cohenad4e15c2013-10-17 16:21:35 -0700737 Runnable exitSpringLoaded = new Runnable() {
738 @Override
739 public void run() {
Sunny Goyal3e3f44c2017-10-23 17:14:52 -0700740 mStateManager.goToState(NORMAL, SPRING_LOADED_EXIT_DELAY);
Adam Cohenad4e15c2013-10-17 16:21:35 -0700741 }
742 };
743
Michael Jurka8b805b12012-04-18 14:23:14 -0700744 if (requestCode == REQUEST_BIND_APPWIDGET) {
Winsona1f79d32015-08-05 14:00:45 -0700745 // This is called only if the user did not previously have permissions to bind widgets
Adam Cohenad4e15c2013-10-17 16:21:35 -0700746 final int appWidgetId = data != null ?
Michael Jurka8b805b12012-04-18 14:23:14 -0700747 data.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1) : -1;
748 if (resultCode == RESULT_CANCELED) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700749 completeTwoStageWidgetDrop(RESULT_CANCELED, appWidgetId, requestArgs);
Adam Cohen689ff162014-05-08 17:27:56 -0700750 mWorkspace.removeExtraEmptyScreenDelayed(true, exitSpringLoaded,
Adam Cohenad4e15c2013-10-17 16:21:35 -0700751 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false);
Michael Jurka8b805b12012-04-18 14:23:14 -0700752 } else if (resultCode == RESULT_OK) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700753 addAppWidgetImpl(
754 appWidgetId, requestArgs, null,
Sunny Goyal04a324a2017-01-20 21:08:59 -0800755 requestArgs.getWidgetHandler(),
Sunny Goyal2100c782016-08-22 16:00:03 -0700756 ON_ACTIVITY_RESULT_ANIMATION_DELAY);
Michael Jurka8b805b12012-04-18 14:23:14 -0700757 }
758 return;
759 }
Michael Jurka336fd4f2013-09-12 00:05:02 +0200760
Adam Cohened66b2b2012-01-23 17:28:51 -0800761 boolean isWidgetDrop = (requestCode == REQUEST_PICK_APPWIDGET ||
Sunny Goyal5c97f512015-05-19 16:03:28 -0700762 requestCode == REQUEST_CREATE_APPWIDGET);
Romain Guyaad5ef42009-06-10 02:48:37 -0700763
Adam Cohened66b2b2012-01-23 17:28:51 -0800764 // We have special handling for widgets
765 if (isWidgetDrop) {
Adam Cohen4637b5a2013-11-04 18:21:24 -0800766 final int appWidgetId;
767 int widgetId = data != null ? data.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1)
768 : -1;
769 if (widgetId < 0) {
770 appWidgetId = pendingAddWidgetId;
771 } else {
772 appWidgetId = widgetId;
773 }
774
Adam Cohenad4e15c2013-10-17 16:21:35 -0700775 final int result;
Adam Cohenf0129b12013-11-04 17:57:36 -0800776 if (appWidgetId < 0 || resultCode == RESULT_CANCELED) {
Adam Cohendb364c32014-05-20 14:23:40 -0700777 Log.e(TAG, "Error: appWidgetId (EXTRA_APPWIDGET_ID) was not " +
778 "returned from the widget configuration activity.");
Adam Cohenad4e15c2013-10-17 16:21:35 -0700779 result = RESULT_CANCELED;
Sunny Goyal2100c782016-08-22 16:00:03 -0700780 completeTwoStageWidgetDrop(result, appWidgetId, requestArgs);
Adam Cohendb364c32014-05-20 14:23:40 -0700781 final Runnable onComplete = new Runnable() {
Adam Cohenad4e15c2013-10-17 16:21:35 -0700782 @Override
783 public void run() {
Sunny Goyal3e3f44c2017-10-23 17:14:52 -0700784 getStateManager().goToState(NORMAL);
Adam Cohenad4e15c2013-10-17 16:21:35 -0700785 }
786 };
Adam Cohendb364c32014-05-20 14:23:40 -0700787
Sunny Goyal2100c782016-08-22 16:00:03 -0700788 mWorkspace.removeExtraEmptyScreenDelayed(true, onComplete,
789 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false);
790 } else {
791 if (requestArgs.container == LauncherSettings.Favorites.CONTAINER_DESKTOP) {
792 // When the screen id represents an actual screen (as opposed to a rank)
793 // we make sure that the drop page actually exists.
794 requestArgs.screenId =
795 ensurePendingDropLayoutExists(requestArgs.screenId);
Adam Cohendb364c32014-05-20 14:23:40 -0700796 }
Sunny Goyal2100c782016-08-22 16:00:03 -0700797 final CellLayout dropLayout =
798 mWorkspace.getScreenWithId(requestArgs.screenId);
799
800 dropLayout.setDropPending(true);
801 final Runnable onComplete = new Runnable() {
802 @Override
803 public void run() {
804 completeTwoStageWidgetDrop(resultCode, appWidgetId, requestArgs);
805 dropLayout.setDropPending(false);
806 }
807 };
808 mWorkspace.removeExtraEmptyScreenDelayed(true, onComplete,
809 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false);
Winson Chung5aaab772012-04-27 15:24:02 -0700810 }
Adam Cohened66b2b2012-01-23 17:28:51 -0800811 return;
812 }
813
Sunny Goyald478c832016-04-01 12:04:16 -0700814 if (requestCode == REQUEST_RECONFIGURE_APPWIDGET
815 || requestCode == REQUEST_BIND_PENDING_APPWIDGET) {
Sunny Goyalff572272014-07-23 13:58:07 -0700816 if (resultCode == RESULT_OK) {
817 // Update the widget view.
Sunny Goyal2100c782016-08-22 16:00:03 -0700818 completeAdd(requestCode, data, pendingAddWidgetId, requestArgs);
Sunny Goyalff572272014-07-23 13:58:07 -0700819 }
820 // Leave the widget in the pending state if the user canceled the configure.
821 return;
822 }
823
Sunny Goyalaad90582015-07-09 14:22:50 -0700824 if (requestCode == REQUEST_CREATE_SHORTCUT) {
825 // Handle custom shortcuts created using ACTION_CREATE_SHORTCUT.
Sunny Goyal2100c782016-08-22 16:00:03 -0700826 if (resultCode == RESULT_OK && requestArgs.container != ItemInfo.NO_ID) {
827 completeAdd(requestCode, data, -1, requestArgs);
828 mWorkspace.removeExtraEmptyScreenDelayed(true, exitSpringLoaded,
829 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false);
830
Sunny Goyalaad90582015-07-09 14:22:50 -0700831 } else if (resultCode == RESULT_CANCELED) {
Adam Cohendb364c32014-05-20 14:23:40 -0700832 mWorkspace.removeExtraEmptyScreenDelayed(true, exitSpringLoaded,
833 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800834 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800835 }
Adam Cohened66b2b2012-01-23 17:28:51 -0800836 mDragLayer.clearAnimatedView();
Adam Cohenc7cd2cb2014-11-17 17:45:34 -0800837 }
838
839 @Override
Sunny Goyal64a75aa2017-07-03 13:50:52 -0700840 public void onActivityResult(
Adam Cohenc7cd2cb2014-11-17 17:45:34 -0800841 final int requestCode, final int resultCode, final Intent data) {
Sunny Goyaldedda052019-05-14 15:23:48 -0700842 mPendingActivityRequestCode = -1;
Adam Cohenc7cd2cb2014-11-17 17:45:34 -0800843 handleActivityResult(requestCode, resultCode, data);
Adam Cohened66b2b2012-01-23 17:28:51 -0800844 }
845
Sunny Goyal7ce471b2017-08-02 03:37:39 -0700846 @Override
Sunny Goyaldd2e6df2015-07-07 10:57:57 -0700847 public void onRequestPermissionsResult(int requestCode, String[] permissions,
Dave Hawkey3a43ed62015-06-26 10:27:47 -0600848 int[] grantResults) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700849 PendingRequestArgs pendingArgs = mPendingRequestArgs;
850 if (requestCode == REQUEST_PERMISSION_CALL_PHONE && pendingArgs != null
851 && pendingArgs.getRequestCode() == REQUEST_PERMISSION_CALL_PHONE) {
852 setWaitingForResult(null);
853
Sunny Goyal28c6b962015-10-12 11:42:05 -0700854 View v = null;
Sunny Goyal2100c782016-08-22 16:00:03 -0700855 CellLayout layout = getCellLayout(pendingArgs.container, pendingArgs.screenId);
Sunny Goyal28c6b962015-10-12 11:42:05 -0700856 if (layout != null) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700857 v = layout.getChildAt(pendingArgs.cellX, pendingArgs.cellY);
Sunny Goyal28c6b962015-10-12 11:42:05 -0700858 }
Sunny Goyal2100c782016-08-22 16:00:03 -0700859 Intent intent = pendingArgs.getPendingIntent();
860
Sunny Goyal28c6b962015-10-12 11:42:05 -0700861 if (grantResults.length > 0
862 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
Sunny Goyal369212a2019-03-26 15:03:57 -0700863 startActivitySafely(v, intent, null, null);
Sunny Goyal28c6b962015-10-12 11:42:05 -0700864 } else {
865 // TODO: Show a snack bar with link to settings
866 Toast.makeText(this, getString(R.string.msg_no_phone_permission,
Sunny Goyal112ce422016-08-22 16:45:29 -0700867 getString(R.string.derived_app_name)), Toast.LENGTH_SHORT).show();
Sunny Goyal28c6b962015-10-12 11:42:05 -0700868 }
869 }
Dave Hawkey3a43ed62015-06-26 10:27:47 -0600870 }
871
Adam Cohendb364c32014-05-20 14:23:40 -0700872 /**
873 * Check to see if a given screen id exists. If not, create it at the end, return the new id.
874 *
875 * @param screenId the screen id to check
876 * @return the new screen, or screenId if it exists
877 */
Sunny Goyalefb7e842018-10-04 15:11:00 -0700878 private int ensurePendingDropLayoutExists(int screenId) {
Sunny Goyal32554d12015-12-03 15:31:25 -0800879 CellLayout dropLayout = mWorkspace.getScreenWithId(screenId);
Adam Cohendb364c32014-05-20 14:23:40 -0700880 if (dropLayout == null) {
881 // it's possible that the add screen was removed because it was
882 // empty and a re-bind occurred
883 mWorkspace.addExtraEmptyScreen();
884 return mWorkspace.commitExtraEmptyScreen();
885 } else {
886 return screenId;
887 }
888 }
889
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700890 @Thunk
891 void completeTwoStageWidgetDrop(
Sunny Goyal2100c782016-08-22 16:00:03 -0700892 final int resultCode, final int appWidgetId, final PendingRequestArgs requestArgs) {
893 CellLayout cellLayout = mWorkspace.getScreenWithId(requestArgs.screenId);
Adam Cohened66b2b2012-01-23 17:28:51 -0800894 Runnable onCompleteRunnable = null;
895 int animationType = 0;
896
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700897 AppWidgetHostView boundWidget = null;
Adam Cohened66b2b2012-01-23 17:28:51 -0800898 if (resultCode == RESULT_OK) {
899 animationType = Workspace.COMPLETE_TWO_STAGE_WIDGET_DROP_ANIMATION;
900 final AppWidgetHostView layout = mAppWidgetHost.createView(this, appWidgetId,
Sunny Goyal04a324a2017-01-20 21:08:59 -0800901 requestArgs.getWidgetHandler().getProviderInfo(this));
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700902 boundWidget = layout;
Adam Cohened66b2b2012-01-23 17:28:51 -0800903 onCompleteRunnable = new Runnable() {
904 @Override
905 public void run() {
Sunny Goyal2100c782016-08-22 16:00:03 -0700906 completeAddAppWidget(appWidgetId, requestArgs, layout, null);
Sunny Goyal3e3f44c2017-10-23 17:14:52 -0700907 mStateManager.goToState(NORMAL, SPRING_LOADED_EXIT_DELAY);
Adam Cohened66b2b2012-01-23 17:28:51 -0800908 }
909 };
910 } else if (resultCode == RESULT_CANCELED) {
Adam Cohen4637b5a2013-11-04 18:21:24 -0800911 mAppWidgetHost.deleteAppWidgetId(appWidgetId);
Adam Cohened66b2b2012-01-23 17:28:51 -0800912 animationType = Workspace.CANCEL_TWO_STAGE_WIDGET_DROP_ANIMATION;
Adam Cohened66b2b2012-01-23 17:28:51 -0800913 }
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700914 if (mDragLayer.getAnimatedView() != null) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700915 mWorkspace.animateWidgetDrop(requestArgs, cellLayout,
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700916 (DragView) mDragLayer.getAnimatedView(), onCompleteRunnable,
917 animationType, boundWidget, true);
Adam Cohenad4e15c2013-10-17 16:21:35 -0700918 } else if (onCompleteRunnable != null) {
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700919 // The animated view may be null in the case of a rotation during widget configuration
920 onCompleteRunnable.run();
921 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800922 }
923
924 @Override
Michael Jurkacd496d72013-04-11 11:32:45 -0700925 protected void onStop() {
926 super.onStop();
Winson Chung0b70cd42019-06-17 22:34:33 -0700927
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700928 if (mDeferOverlayCallbacks) {
929 checkIfOverlayStillDeferred();
930 } else {
931 mOverlayManager.onActivityStopped(this);
Adam Cohen9211d422014-10-07 18:14:53 -0700932 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700933
Becky Qiubfc2da12019-08-01 11:09:38 -0700934 logStopAndResume(Action.Command.STOP);
Hyunyoung Songbd6fba92018-05-16 15:54:31 -0700935
936 mAppWidgetHost.setListenIfResumed(false);
937
Tony Wickham010d2552017-01-20 08:15:28 -0800938 NotificationListener.removeNotificationsChangedListener();
Sunny Goyalaf161fd2018-02-05 16:34:57 -0800939 getStateManager().moveToRestState();
Winson Chungedb0d6b2018-03-21 17:32:55 -0700940
Winson Chungdea51352018-04-24 13:02:10 -0700941 // Workaround for b/78520668, explicitly trim memory once UI is hidden
Winson Chung473730f2018-04-26 11:54:22 -0700942 onTrimMemory(TRIM_MEMORY_UI_HIDDEN);
Michael Jurkacd496d72013-04-11 11:32:45 -0700943 }
944
945 @Override
946 protected void onStart() {
Winson Chung5cc62c72019-10-16 11:32:41 -0700947 Object traceToken = TraceHelper.INSTANCE.beginSection(ON_START_EVT,
948 TraceHelper.FLAG_UI_EVENT);
Michael Jurkacd496d72013-04-11 11:32:45 -0700949 super.onStart();
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700950 if (!mDeferOverlayCallbacks) {
951 mOverlayManager.onActivityStarted(this);
Adam Cohen9211d422014-10-07 18:14:53 -0700952 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700953
Sunny Goyal67419a12017-11-14 16:55:22 -0800954 mAppWidgetHost.setListenIfResumed(true);
Winson Chung5cc62c72019-10-16 11:32:41 -0700955 TraceHelper.INSTANCE.endSection(traceToken);
Michael Jurkacd496d72013-04-11 11:32:45 -0700956 }
957
Sunny Goyala002c6c2019-02-12 16:20:10 -0800958 private void handleDeferredResume() {
Sunny Goyale9c6f4c2019-05-30 11:35:25 -0700959 if (hasBeenResumed() && !mStateManager.getState().disableInteraction) {
Becky Qiubfc2da12019-08-01 11:09:38 -0700960 logStopAndResume(Action.Command.RESUME);
Hyunyoung Songbd6fba92018-05-16 15:54:31 -0700961 getUserEventDispatcher().startSession();
Sunny Goyala002c6c2019-02-12 16:20:10 -0800962
Sunny Goyal369212a2019-03-26 15:03:57 -0700963 AppLaunchTracker.INSTANCE.get(this).onReturnedToHome();
Hyunyoung Songbd6fba92018-05-16 15:54:31 -0700964
Sunny Goyale9c6f4c2019-05-30 11:35:25 -0700965 // Process any items that were added while Launcher was away.
966 InstallShortcutReceiver.disableAndFlushInstallQueue(
967 InstallShortcutReceiver.FLAG_ACTIVITY_PAUSED, this);
968
969 // Refresh shortcuts if the permission changed.
970 mModel.refreshShortcutsIfRequired();
971
Winson Chung87583112019-06-10 14:20:58 -0700972 // Set the notification listener and fetch updated notifications when we resume
973 NotificationListener.setNotificationsChangedListener(mPopupDataProvider);
974
Sunny Goyale9c6f4c2019-05-30 11:35:25 -0700975 DiscoveryBounce.showForHomeIfNeeded(this);
976
Sunny Goyal210e1742019-10-17 12:05:38 -0700977 onDeferredResumed();
978 addActivityFlags(ACTIVITY_STATE_DEFERRED_RESUMED);
979
Sunny Goyale9c6f4c2019-05-30 11:35:25 -0700980 mDeferredResumePending = false;
981 } else {
982 mDeferredResumePending = true;
Sunny Goyaldedda052019-05-14 15:23:48 -0700983 }
984 }
985
Sunny Goyal210e1742019-10-17 12:05:38 -0700986 protected void onDeferredResumed() { }
987
Becky Qiubfc2da12019-08-01 11:09:38 -0700988 private void logStopAndResume(int command) {
989 int containerType = mStateManager.getState().containerType;
990 if (containerType == ContainerType.WORKSPACE && mWorkspace != null) {
991 getUserEventDispatcher().logActionCommand(command,
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700992 containerType, -1, mWorkspace.isOverlayShown() ? -1 : 0);
Becky Qiubfc2da12019-08-01 11:09:38 -0700993 } else {
994 getUserEventDispatcher().logActionCommand(command, containerType, -1);
995 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700996 }
Becky Qiubfc2da12019-08-01 11:09:38 -0700997
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700998 private void scheduleDeferredCheck() {
999 mHandler.removeCallbacks(mDeferredOverlayCallbacks);
1000 postAsyncCallback(mHandler, mDeferredOverlayCallbacks);
1001 }
1002
1003 private void checkIfOverlayStillDeferred() {
1004 if (!mDeferOverlayCallbacks) {
1005 return;
1006 }
1007 if (isStarted() && (!hasBeenResumed() || mStateManager.getState().disableInteraction)) {
1008 return;
1009 }
1010 mDeferOverlayCallbacks = false;
1011
1012 // Move the client to the correct state. Calling the same method twice is no-op.
1013 if (isStarted()) {
1014 mOverlayManager.onActivityStarted(this);
1015 }
1016 if (hasBeenResumed()) {
1017 mOverlayManager.onActivityResumed(this);
1018 } else {
1019 mOverlayManager.onActivityPaused(this);
1020 }
1021 if (!isStarted()) {
1022 mOverlayManager.onActivityStopped(this);
1023 }
1024 }
1025
1026 public void deferOverlayCallbacksUntilNextResumeOrStop() {
1027 mDeferOverlayCallbacks = true;
1028 }
1029
1030 public LauncherOverlayManager getOverlayManager() {
1031 return mOverlayManager;
Becky Qiubfc2da12019-08-01 11:09:38 -07001032 }
1033
Winson Chungef528762019-09-06 12:05:52 -07001034 public void onStateSetStart(LauncherState state) {
Sunny Goyale9c6f4c2019-05-30 11:35:25 -07001035 if (mDeferredResumePending) {
1036 handleDeferredResume();
1037 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001038 if (mDeferOverlayCallbacks) {
1039 scheduleDeferredCheck();
Sunny Goyale9c6f4c2019-05-30 11:35:25 -07001040 }
Sunny Goyal210e1742019-10-17 12:05:38 -07001041 addActivityFlags(ACTIVITY_STATE_TRANSITION_ACTIVE);
Sunny Goyaldedda052019-05-14 15:23:48 -07001042 }
1043
Winson Chungef528762019-09-06 12:05:52 -07001044 public void onStateSetEnd(LauncherState state) {
1045 getAppWidgetHost().setResumed(state == LauncherState.NORMAL);
1046 getWorkspace().setClipChildren(!state.disablePageClipping);
1047 finishAutoCancelActionMode();
Sunny Goyal210e1742019-10-17 12:05:38 -07001048 removeActivityFlags(ACTIVITY_STATE_TRANSITION_ACTIVE);
Winson Chungef528762019-09-06 12:05:52 -07001049 }
1050
Michael Jurkacd496d72013-04-11 11:32:45 -07001051 @Override
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001052 protected void onResume() {
Winson Chung5cc62c72019-10-16 11:32:41 -07001053 Object traceToken = TraceHelper.INSTANCE.beginSection(ON_RESUME_EVT,
1054 TraceHelper.FLAG_UI_EVENT);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001055 super.onResume();
Sunny Goyalfca6bc92017-09-28 16:28:34 -07001056
Sunny Goyala002c6c2019-02-12 16:20:10 -08001057 mHandler.removeCallbacks(mHandleDeferredResume);
1058 Utilities.postAsyncCallback(mHandler, mHandleDeferredResume);
Hyunyoung Songbd6fba92018-05-16 15:54:31 -07001059
Winson Chung940b0ac2019-07-09 11:33:50 -07001060 if (!mOnResumeCallbacks.isEmpty()) {
1061 final ArrayList<OnResumeCallback> resumeCallbacks = new ArrayList<>(mOnResumeCallbacks);
1062 mOnResumeCallbacks.clear();
1063 for (int i = resumeCallbacks.size() - 1; i >= 0; i--) {
1064 resumeCallbacks.get(i).onLauncherResume();
1065 }
1066 resumeCallbacks.clear();
Winson Chung0b70cd42019-06-17 22:34:33 -07001067 }
Sunny Goyal95f3d6b2016-08-10 16:09:29 -07001068
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001069 if (mDeferOverlayCallbacks) {
1070 scheduleDeferredCheck();
1071 } else {
1072 mOverlayManager.onActivityResumed(this);
Adam Cohen9211d422014-10-07 18:14:53 -07001073 }
Mario Bertschler0fc6f682017-02-17 12:16:13 -08001074
Winson Chung5cc62c72019-10-16 11:32:41 -07001075 TraceHelper.INSTANCE.endSection(traceToken);
Adam Cohen06dff352012-06-01 17:17:08 -07001076 }
1077
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001078 @Override
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001079 protected void onPause() {
Winson Chung997a9232013-07-24 15:33:46 -07001080 // Ensure that items added to Launcher are queued until Launcher returns
Sunny Goyala474a9b2017-05-04 16:47:11 -07001081 InstallShortcutReceiver.enableInstallQueue(InstallShortcutReceiver.FLAG_ACTIVITY_PAUSED);
Winson Chung997a9232013-07-24 15:33:46 -07001082
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001083 super.onPause();
Joe Onorato24b6fd82009-11-12 13:47:09 -08001084 mDragController.cancelDrag();
Winson Chunga2413752012-04-03 14:22:34 -07001085 mDragController.resetLastGestureUpTime();
Hyunyoung Song497708c2019-05-01 16:16:53 -07001086 mDropTargetBar.animateToVisibility(false);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001087
1088 if (!mDeferOverlayCallbacks) {
1089 mOverlayManager.onActivityPaused(this);
Adam Cohenbffe7452013-07-22 18:21:45 -07001090 }
Adam Cohenbffe7452013-07-22 18:21:45 -07001091 }
1092
Adam Cohenc2d6e892014-10-16 09:49:24 -07001093 class LauncherOverlayCallbacksImpl implements LauncherOverlayCallbacks {
1094
Sunny Goyalc86df472016-02-25 09:19:38 -08001095 public void onScrollChanged(float progress) {
1096 if (mWorkspace != null) {
1097 mWorkspace.onOverlayScrollChanged(progress);
1098 }
1099 }
Adam Cohenc2d6e892014-10-16 09:49:24 -07001100 }
1101
Sunny Goyalf9403d92017-10-18 10:55:56 -07001102 public boolean isInState(LauncherState state) {
Sunny Goyalea609262017-10-25 15:47:38 -07001103 return mStateManager.getState() == state;
Sunny Goyalf9403d92017-10-18 10:55:56 -07001104 }
1105
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001106 /**
1107 * Restores the previous state, if it exists.
1108 *
1109 * @param savedState The previous state.
1110 */
1111 private void restoreState(Bundle savedState) {
1112 if (savedState == null) {
1113 return;
1114 }
1115
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001116 int stateOrdinal = savedState.getInt(RUNTIME_STATE, NORMAL.ordinal);
Sunny Goyalf9403d92017-10-18 10:55:56 -07001117 LauncherState[] stateValues = LauncherState.values();
1118 LauncherState state = stateValues[stateOrdinal];
Sunny Goyalbc683e92017-12-06 10:25:07 -08001119 if (!state.disableRestore) {
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001120 mStateManager.goToState(state, false /* animated */);
Joe Onorato3a8820b2009-11-10 15:06:42 -08001121 }
1122
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001123 PendingRequestArgs requestArgs = savedState.getParcelable(
1124 RUNTIME_STATE_PENDING_REQUEST_ARGS);
Sunny Goyal2100c782016-08-22 16:00:03 -07001125 if (requestArgs != null) {
1126 setWaitingForResult(requestArgs);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001127 }
Sunny Goyaldedda052019-05-14 15:23:48 -07001128 mPendingActivityRequestCode = savedState.getInt(RUNTIME_STATE_PENDING_REQUEST_CODE);
Sunny Goyal2100c782016-08-22 16:00:03 -07001129
1130 mPendingActivityResult = savedState.getParcelable(RUNTIME_STATE_PENDING_ACTIVITY_RESULT);
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001131
1132 SparseArray<Parcelable> widgetsState =
1133 savedState.getSparseParcelableArray(RUNTIME_STATE_WIDGET_PANEL);
1134 if (widgetsState != null) {
1135 WidgetsFullSheet.show(this, false).restoreHierarchyState(widgetsState);
1136 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001137 }
1138
1139 /**
1140 * Finds all the views we need and configure them properly.
1141 */
Tony Wickham04fca162020-02-05 15:06:52 -08001142 protected void setupViews() {
Sunny Goyalcc96aa12018-01-11 09:56:07 -08001143 mDragLayer = findViewById(R.id.drag_layer);
Sunny Goyal3333b0c2016-05-09 20:43:21 -07001144 mFocusHandler = mDragLayer.getFocusIndicatorHelper();
Sunny Goyal966d9012017-06-06 16:43:59 -07001145 mWorkspace = mDragLayer.findViewById(R.id.workspace);
Sunny Goyald0a6ae72016-06-16 12:29:03 -07001146 mWorkspace.initParentViews(mDragLayer);
Sreyas321bfae2020-02-21 17:53:02 -08001147 mOverviewPanel = findViewById(R.id.overview_panel);
1148 mActionsView = findViewById(R.id.overview_actions_view);
Sunny Goyal7c7be8c2018-03-07 19:58:07 -08001149 mHotseat = findViewById(R.id.hotseat);
Craig Mautner360310b2012-10-26 15:13:08 -07001150
Sunny Goyal784f9c32016-03-23 16:56:54 -07001151 mLauncherView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
1152 | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
1153 | View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001154
Winson Chung4c98d922011-05-31 16:50:48 -07001155 // Setup the drag layer
Sunny Goyal5d1873a2018-05-08 11:10:44 -07001156 mDragLayer.setup(mDragController, mWorkspace);
Winson Chung4c98d922011-05-31 16:50:48 -07001157
Hyunyoung Song645764e2016-06-06 14:19:02 -07001158 mWorkspace.setup(mDragController);
Winsonc7d2e832016-07-28 12:24:55 -07001159 // Until the workspace is bound, ensure that we keep the wallpaper offset locked to the
1160 // default state, otherwise we will update to the wrong offsets in RTL
1161 mWorkspace.lockWallpaperToDefaultPage();
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07001162 mWorkspace.bindAndInitFirstWorkspaceScreen(null /* recycled qsb */);
Hyunyoung Song645764e2016-06-06 14:19:02 -07001163 mDragController.addDragListener(mWorkspace);
Winson Chung4c98d922011-05-31 16:50:48 -07001164
Tony Wickham34d2c912015-09-11 09:27:58 -07001165 // Get the search/delete/uninstall bar
Rajeev Kumar43c0f582017-06-23 15:34:55 -07001166 mDropTargetBar = mDragLayer.findViewById(R.id.drop_target_bar);
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07001167
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001168 // Setup Apps
1169 mAppsView = findViewById(R.id.apps_view);
Craig Mautner360310b2012-10-26 15:13:08 -07001170
Govinda Wassermanc06e1512019-04-09 09:56:53 -04001171 // Setup Scrim
1172 mScrimView = findViewById(R.id.scrim_view);
1173
Winson Chung3d503fb2011-07-13 17:25:49 -07001174 // Setup the drag controller (drop targets have to be added in reverse order in priority)
Hyunyoung Song645764e2016-06-06 14:19:02 -07001175 mDragController.setMoveTarget(mWorkspace);
Sunny Goyal47328fd2016-05-25 18:56:41 -07001176 mDropTargetBar.setup(mDragController);
Daniel Sandler924b9932013-06-12 00:38:25 -04001177
Sunny Goyal7185dd62018-03-14 17:51:49 -07001178 mAllAppsController.setupViews(mAppsView);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001179 }
1180
1181 /**
1182 * Creates a view representing a shortcut.
1183 *
1184 * @param info The data structure describing the shortcut.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001185 */
Sunny Goyal95899162019-03-27 16:03:06 -07001186 View createShortcut(WorkspaceItemInfo info) {
Sunny Goyaldfaccf62015-05-11 16:30:44 -07001187 return createShortcut((ViewGroup) mWorkspace.getChildAt(mWorkspace.getCurrentPage()), info);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001188 }
1189
1190 /**
1191 * Creates a view representing a shortcut inflated from the specified resource.
1192 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001193 * @param parent The group the shortcut belongs to.
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001194 * @param info The data structure describing the shortcut.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001195 * @return A View inflated from layoutResId.
1196 */
Sunny Goyal95899162019-03-27 16:03:06 -07001197 public View createShortcut(ViewGroup parent, WorkspaceItemInfo info) {
Sunny Goyal9b29ca52017-02-17 10:39:44 -08001198 BubbleTextView favorite = (BubbleTextView) LayoutInflater.from(parent.getContext())
1199 .inflate(R.layout.app_icon, parent, false);
Sunny Goyal95899162019-03-27 16:03:06 -07001200 favorite.applyFromWorkspaceItem(info);
Sunny Goyal8a2a63b2018-03-06 22:15:18 -08001201 favorite.setOnClickListener(ItemClickHandler.INSTANCE);
Sunny Goyaldcbcc862014-08-12 15:58:36 -07001202 favorite.setOnFocusChangeListener(mFocusHandler);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001203 return favorite;
1204 }
1205
1206 /**
Jon Mirandac476d6e2017-05-04 16:30:01 -07001207 * Add a shortcut to the workspace or to a Folder.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001208 *
1209 * @param data The intent describing the shortcut.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001210 */
Sunny Goyalefb7e842018-10-04 15:11:00 -07001211 private void completeAddShortcut(Intent data, int container, int screenId, int cellX,
Sunny Goyalfb5096d2016-09-08 14:32:06 -07001212 int cellY, PendingRequestArgs args) {
Pinyao Ting5eee5f42019-10-31 16:47:35 -07001213 if (args.getRequestCode() != REQUEST_CREATE_SHORTCUT
Jon Mirandac476d6e2017-05-04 16:30:01 -07001214 || args.getPendingIntent().getComponent() == null) {
Sunny Goyalfb5096d2016-09-08 14:32:06 -07001215 return;
1216 }
Adam Cohen558baaf2011-08-15 15:22:57 -07001217
Jon Mirandac476d6e2017-05-04 16:30:01 -07001218 int[] cellXY = mTmpAddItemCellCoordinates;
1219 CellLayout layout = getCellLayout(container, screenId);
1220
Sunny Goyal95899162019-03-27 16:03:06 -07001221 WorkspaceItemInfo info = null;
Hyunyoung Songe24cb632017-09-11 11:18:03 -07001222 if (Utilities.ATLEAST_OREO) {
Sunny Goyale7b00122019-10-02 16:13:34 -07001223 info = PinRequestHelper.createWorkspaceItemFromPinItemRequest(
1224 this, PinRequestHelper.getPinItemRequest(data), 0);
Sunny Goyal782f0c92017-01-19 10:27:54 -08001225 }
1226
1227 if (info == null) {
Sunny Goyalb57645f2017-03-20 13:57:28 -07001228 // Legacy shortcuts are only supported for primary profile.
1229 info = Process.myUserHandle().equals(args.user)
1230 ? InstallShortcutReceiver.fromShortcutIntent(this, data) : null;
Sunny Goyal782f0c92017-01-19 10:27:54 -08001231
Sunny Goyalb57645f2017-03-20 13:57:28 -07001232 if (info == null) {
1233 Log.e(TAG, "Unable to parse a valid custom shortcut result");
1234 return;
1235 } else if (!new PackageManagerHelper(this).hasPermissionForActivity(
Sunny Goyal342e4662017-02-02 15:21:08 -08001236 info.intent, args.getPendingIntent().getComponent().getPackageName())) {
Sunny Goyal782f0c92017-01-19 10:27:54 -08001237 // The app is trying to add a shortcut without sufficient permissions
1238 Log.e(TAG, "Ignoring malicious intent " + info.intent.toUri(0));
1239 return;
1240 }
1241 }
1242
Jon Mirandac476d6e2017-05-04 16:30:01 -07001243 if (container < 0) {
1244 // Adding a shortcut to the Workspace.
1245 final View view = createShortcut(info);
1246 boolean foundCellSpan = false;
1247 // First we check if we already know the exact location where we want to add this item.
1248 if (cellX >= 0 && cellY >= 0) {
1249 cellXY[0] = cellX;
1250 cellXY[1] = cellY;
1251 foundCellSpan = true;
Adam Cohen558baaf2011-08-15 15:22:57 -07001252
Hyunyoung Song1ae42422020-01-26 23:25:14 -08001253 DragObject dragObject = new DragObject(getApplicationContext());
1254 dragObject.dragInfo = info;
Jon Mirandac476d6e2017-05-04 16:30:01 -07001255 // If appropriate, either create a folder or add to an existing folder
1256 if (mWorkspace.createUserFolderIfNecessary(view, container, layout, cellXY, 0,
Hyunyoung Song1ae42422020-01-26 23:25:14 -08001257 true, dragObject)) {
Jon Mirandac476d6e2017-05-04 16:30:01 -07001258 return;
1259 }
Jon Mirandac476d6e2017-05-04 16:30:01 -07001260 if (mWorkspace.addToExistingFolderIfNecessary(view, layout, cellXY, 0, dragObject,
1261 true)) {
1262 return;
1263 }
1264 } else {
1265 foundCellSpan = layout.findCellForSpan(cellXY, 1, 1);
1266 }
1267
1268 if (!foundCellSpan) {
1269 mWorkspace.onNoCellFound(layout);
Adam Cohen558baaf2011-08-15 15:22:57 -07001270 return;
1271 }
Jon Mirandac476d6e2017-05-04 16:30:01 -07001272
1273 getModelWriter().addItemToDatabase(info, container, screenId, cellXY[0], cellXY[1]);
1274 mWorkspace.addInScreen(view, info);
Michael Jurkad3ef3062010-11-23 16:23:58 -08001275 } else {
Jon Mirandac476d6e2017-05-04 16:30:01 -07001276 // Adding a shortcut to a Folder.
Sunny Goyale29897f52017-07-20 10:09:42 -07001277 FolderIcon folderIcon = findFolderIcon(container);
Jon Mirandac476d6e2017-05-04 16:30:01 -07001278 if (folderIcon != null) {
1279 FolderInfo folderInfo = (FolderInfo) folderIcon.getTag();
1280 folderInfo.add(info, args.rank, false);
1281 } else {
Sunny Goyale29897f52017-07-20 10:09:42 -07001282 Log.e(TAG, "Could not find folder with id " + container + " to add shortcut.");
Jon Mirandac476d6e2017-05-04 16:30:01 -07001283 }
Michael Jurka0280c3b2010-09-17 15:00:07 -07001284 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001285 }
1286
Sunny Goyalefb7e842018-10-04 15:11:00 -07001287 public FolderIcon findFolderIcon(final int folderIconId) {
Sunny Goyal83fd25e2018-07-09 16:47:01 -07001288 return (FolderIcon) mWorkspace.getHomescreenIconByItemId(folderIconId);
Sunny Goyale29897f52017-07-20 10:09:42 -07001289 }
1290
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001291 /**
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001292 * Add a widget to the workspace.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001293 *
Romain Guy5bbc91b2010-08-18 11:38:46 -07001294 * @param appWidgetId The app widget id
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001295 */
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001296 @Thunk
1297 void completeAddAppWidget(int appWidgetId, ItemInfo itemInfo,
Adam Cohen59400422014-03-05 18:07:04 -08001298 AppWidgetHostView hostView, LauncherAppWidgetProviderInfo appWidgetInfo) {
1299
Adam Cohened66b2b2012-01-23 17:28:51 -08001300 if (appWidgetInfo == null) {
Sunny Goyal2e1efb42016-03-03 16:58:55 -08001301 appWidgetInfo = mAppWidgetManager.getLauncherAppWidgetInfo(appWidgetId);
Adam Cohened66b2b2012-01-23 17:28:51 -08001302 }
Romain Guycbb89e42009-06-08 15:52:54 -07001303
Adam Cohen59400422014-03-05 18:07:04 -08001304 LauncherAppWidgetInfo launcherInfo;
1305 launcherInfo = new LauncherAppWidgetInfo(appWidgetId, appWidgetInfo.provider);
Sunny Goyal2100c782016-08-22 16:00:03 -07001306 launcherInfo.spanX = itemInfo.spanX;
1307 launcherInfo.spanY = itemInfo.spanY;
1308 launcherInfo.minSpanX = itemInfo.minSpanX;
1309 launcherInfo.minSpanY = itemInfo.minSpanY;
Sunny Goyal952e63d2017-08-16 04:59:08 -07001310 launcherInfo.user = appWidgetInfo.getProfile();
Romain Guycbb89e42009-06-08 15:52:54 -07001311
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001312 getModelWriter().addItemToDatabase(launcherInfo,
Sunny Goyal2100c782016-08-22 16:00:03 -07001313 itemInfo.container, itemInfo.screenId, itemInfo.cellX, itemInfo.cellY);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001314
Sunny Goyal2100c782016-08-22 16:00:03 -07001315 if (hostView == null) {
1316 // Perform actual inflation because we're live
1317 hostView = mAppWidgetHost.createView(this, appWidgetId, appWidgetInfo);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001318 }
Sunny Goyal2100c782016-08-22 16:00:03 -07001319 hostView.setVisibility(View.VISIBLE);
Sunny Goyald5462aa2016-11-22 16:52:39 +05301320 prepareAppWidget(hostView, launcherInfo);
1321 mWorkspace.addInScreen(hostView, launcherInfo);
Pinyao Tingc9074272019-11-11 11:51:44 -08001322 announceForAccessibility(R.string.item_added_to_workspace);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001323 }
Romain Guycbb89e42009-06-08 15:52:54 -07001324
Sunny Goyald5462aa2016-11-22 16:52:39 +05301325 private void prepareAppWidget(AppWidgetHostView hostView, LauncherAppWidgetInfo item) {
Sunny Goyal87af0fd2016-05-16 14:56:02 -07001326 hostView.setTag(item);
1327 item.onBindAppWidget(this, hostView);
Sunny Goyal87af0fd2016-05-16 14:56:02 -07001328 hostView.setFocusable(true);
1329 hostView.setOnFocusChangeListener(mFocusHandler);
Sunny Goyal25c2e3e2015-10-28 23:28:21 -07001330 }
1331
Sunny Goyal5d1873a2018-05-08 11:10:44 -07001332 private final BroadcastReceiver mScreenOffReceiver = new BroadcastReceiver() {
Adam Cohended9f8d2010-11-03 13:25:16 -07001333 @Override
1334 public void onReceive(Context context, Intent intent) {
Sunny Goyal5d1873a2018-05-08 11:10:44 -07001335 // Reset AllApps to its initial state only if we are not in the middle of
1336 // processing a multi-step drop
1337 if (mPendingRequestArgs == null) {
1338 mStateManager.goToState(NORMAL);
Adam Cohended9f8d2010-11-03 13:25:16 -07001339 }
1340 }
1341 };
1342
Sunny Goyal9c2b9602020-01-07 13:07:55 -08001343 private void updateNotificationDots(Predicate<PackageUserKey> updatedDots) {
Tony Wickhamf34bee82018-12-03 18:11:39 -08001344 mWorkspace.updateNotificationDots(updatedDots);
1345 mAppsView.getAppsStore().updateNotificationDots(updatedDots);
Tony Wickham010d2552017-01-20 08:15:28 -08001346 }
1347
Adam Cohended9f8d2010-11-03 13:25:16 -07001348 @Override
1349 public void onAttachedToWindow() {
1350 super.onAttachedToWindow();
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001351 mOverlayManager.onAttachedToWindow();
Adam Cohended9f8d2010-11-03 13:25:16 -07001352 }
1353
1354 @Override
1355 public void onDetachedFromWindow() {
1356 super.onDetachedFromWindow();
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001357 mOverlayManager.onDetachedFromWindow();
1358 closeContextMenu();
Adam Cohended9f8d2010-11-03 13:25:16 -07001359 }
1360
Sunny Goyalc4fa8c32017-11-07 12:23:58 -08001361 public AllAppsTransitionController getAllAppsController() {
1362 return mAllAppsController;
1363 }
1364
Sunny Goyal9d69c8d2018-03-19 13:41:31 -07001365 @Override
Winson Chung1a341002018-01-17 10:00:23 -08001366 public LauncherRootView getRootView() {
1367 return (LauncherRootView) mLauncherView;
1368 }
1369
Sunny Goyal0b0847b2018-03-14 12:30:11 -07001370 @Override
Winson Chunga6945242014-01-08 14:04:34 -08001371 public DragLayer getDragLayer() {
1372 return mDragLayer;
1373 }
1374
Winson Chung5f4e0fd2015-05-22 11:12:27 -07001375 public AllAppsContainerView getAppsView() {
Winson Chungb745afb2015-03-02 11:51:23 -08001376 return mAppsView;
1377 }
1378
Winson Chunga6945242014-01-08 14:04:34 -08001379 public Workspace getWorkspace() {
1380 return mWorkspace;
1381 }
1382
1383 public Hotseat getHotseat() {
1384 return mHotseat;
1385 }
1386
Sunny Goyal7c7be8c2018-03-07 19:58:07 -08001387 public <T extends View> T getOverviewPanel() {
Winson Chung8ae41982017-11-10 11:42:13 -08001388 return (T) mOverviewPanel;
Winson Chunga6945242014-01-08 14:04:34 -08001389 }
1390
Sreyas321bfae2020-02-21 17:53:02 -08001391 public View getActionsView() {
1392 return mActionsView;
Sreyasa241df62020-02-05 16:58:34 -08001393 }
1394
Sunny Goyal47328fd2016-05-25 18:56:41 -07001395 public DropTargetBar getDropTargetBar() {
1396 return mDropTargetBar;
Tony Wickham34d2c912015-09-11 09:27:58 -07001397 }
1398
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001399 public LauncherAppWidgetHost getAppWidgetHost() {
1400 return mAppWidgetHost;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001401 }
Romain Guycbb89e42009-06-08 15:52:54 -07001402
Winson Chunga9abd0e2010-10-27 17:18:37 -07001403 public LauncherModel getModel() {
1404 return mModel;
1405 }
1406
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001407 public ModelWriter getModelWriter() {
1408 return mModelWriter;
1409 }
1410
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001411 @Override
Adam Cohen79d90c52016-04-22 13:29:20 -07001412 public SharedPreferences getSharedPrefs() {
Winson Chunga6945242014-01-08 14:04:34 -08001413 return mSharedPrefs;
1414 }
1415
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001416 @Override
1417 public SharedPreferences getDevicePrefs() {
1418 return Utilities.getDevicePrefs(this);
1419 }
1420
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001421 public int getOrientation() {
1422 return mOldConfig.orientation;
1423 }
Jon Miranda6bed3502017-09-19 14:43:17 -07001424
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001425 @Override
1426 protected void onNewIntent(Intent intent) {
vadimtbaf5fbb2019-12-16 18:56:09 -08001427 if (Utilities.IS_RUNNING_IN_TEST_HARNESS) {
1428 Log.d(TestProtocol.PERMANENT_DIAG_TAG, "Launcher.onNewIntent: " + intent);
1429 }
Winson Chung5cc62c72019-10-16 11:32:41 -07001430 Object traceToken = TraceHelper.INSTANCE.beginSection(ON_NEW_INTENT_EVT);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001431 super.onNewIntent(intent);
1432
Sunny Goyalf4aceab2017-12-06 16:16:31 -08001433 boolean alreadyOnHome = hasWindowFocus() && ((intent.getFlags() &
Winson15f8b172015-08-19 11:02:39 -07001434 Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT)
1435 != Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT);
Sunny Goyal85313732016-09-28 12:00:07 -07001436
1437 // Check this condition before handling isActionMain, as this will get reset.
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001438 boolean shouldMoveToDefaultScreen = alreadyOnHome && isInState(NORMAL)
Sunny Goyalf9403d92017-10-18 10:55:56 -07001439 && AbstractFloatingView.getTopOpenView(this) == null;
Winson15f8b172015-08-19 11:02:39 -07001440 boolean isActionMain = Intent.ACTION_MAIN.equals(intent.getAction());
Sunny Goyale84c5b82019-09-26 17:05:31 -07001441 boolean internalStateHandled = ACTIVITY_TRACKER.handleNewIntent(this, intent);
Sunny Goyald3864fa2017-11-14 15:06:36 -08001442
Winson15f8b172015-08-19 11:02:39 -07001443 if (isActionMain) {
Sunny Goyald3864fa2017-11-14 15:06:36 -08001444 if (!internalStateHandled) {
Sunny Goyald3864fa2017-11-14 15:06:36 -08001445 // In all these cases, only animate if we're already on home
Sunny Goyalcc96aa12018-01-11 09:56:07 -08001446 AbstractFloatingView.closeAllOpenViews(this, isStarted());
Jon Mirandafeba90f2016-10-06 10:53:29 -07001447
Sunny Goyala2467272018-03-16 14:53:05 -07001448 if (!isInState(NORMAL)) {
1449 // Only change state, if not already the same. This prevents cancelling any
1450 // animations running as part of resume
1451 mStateManager.goToState(NORMAL);
1452 }
Sunny Goyald3864fa2017-11-14 15:06:36 -08001453
1454 // Reset the apps view
Sunny Goyal5d1873a2018-05-08 11:10:44 -07001455 if (!alreadyOnHome) {
Sunny Goyal7185dd62018-03-14 17:51:49 -07001456 mAppsView.reset(isStarted() /* animate */);
Sunny Goyald3864fa2017-11-14 15:06:36 -08001457 }
1458
Sunny Goyalaad33592018-08-07 17:20:35 -07001459 if (shouldMoveToDefaultScreen && !mWorkspace.isHandlingTouch()) {
Sunny Goyald3864fa2017-11-14 15:06:36 -08001460 mWorkspace.post(mWorkspace::moveToDefaultScreen);
1461 }
1462 }
Adam Cohen6fecd412013-10-02 17:41:50 -07001463
Hyunyoung Song2a70b3d2019-06-11 12:47:07 -07001464 // Handle HOME_INTENT
1465 UserEventDispatcher ued = getUserEventDispatcher();
1466 Target target = newContainerTarget(mStateManager.getState().containerType);
1467 target.pageIndex = mWorkspace.getCurrentPage();
1468 ued.logActionCommand(Action.Command.HOME_INTENT, target,
1469 newContainerTarget(ContainerType.WORKSPACE));
1470
Adam Cohen6fecd412013-10-02 17:41:50 -07001471 final View v = getWindow().peekDecorView();
1472 if (v != null && v.getWindowToken() != null) {
Sunny Goyal326403e2017-10-02 12:45:10 -07001473 UiThreadHelper.hideKeyboardAsync(this, v.getWindowToken());
Adam Cohen6fecd412013-10-02 17:41:50 -07001474 }
1475
Adam Cohen9211d422014-10-07 18:14:53 -07001476 if (mLauncherCallbacks != null) {
Sunny Goyal85462132018-04-24 11:39:37 -07001477 mLauncherCallbacks.onHomeIntent(internalStateHandled);
Adam Cohen9211d422014-10-07 18:14:53 -07001478 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001479 mOverlayManager.hideOverlay(isStarted() && !isForceInvisible());
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001480 }
Winson15f8b172015-08-19 11:02:39 -07001481
Winson Chung5cc62c72019-10-16 11:32:41 -07001482 TraceHelper.INSTANCE.endSection(traceToken);
Adam Coppa120b8e2013-11-12 16:26:04 +00001483 }
1484
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001485 @Override
Adam Cohen1462de32012-07-24 22:34:36 -07001486 public void onRestoreInstanceState(Bundle state) {
1487 super.onRestoreInstanceState(state);
Sunny Goyalf4aceab2017-12-06 16:16:31 -08001488 mWorkspace.restoreInstanceStateForChild(mSynchronouslyBoundPage);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001489 }
1490
1491 @Override
1492 protected void onSaveInstanceState(Bundle outState) {
Adam Cohen21cd0022013-10-09 18:57:02 -07001493 if (mWorkspace.getChildCount() > 0) {
Sunny Goyal7ce471b2017-08-02 03:37:39 -07001494 outState.putInt(RUNTIME_STATE_CURRENT_SCREEN, mWorkspace.getNextPage());
Hyunyoung Song645764e2016-06-06 14:19:02 -07001495
Adam Cohen21cd0022013-10-09 18:57:02 -07001496 }
Sunny Goyalea609262017-10-25 15:47:38 -07001497 outState.putInt(RUNTIME_STATE, mStateManager.getState().ordinal);
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001498
1499
1500 AbstractFloatingView widgets = AbstractFloatingView
1501 .getOpenView(this, AbstractFloatingView.TYPE_WIDGETS_FULL_SHEET);
1502 if (widgets != null) {
1503 SparseArray<Parcelable> widgetsState = new SparseArray<>();
1504 widgets.saveHierarchyState(widgetsState);
1505 outState.putSparseParcelableArray(RUNTIME_STATE_WIDGET_PANEL, widgetsState);
1506 } else {
1507 outState.remove(RUNTIME_STATE_WIDGET_PANEL);
1508 }
1509
Pinyao Tinga74b63a2019-07-17 23:26:06 -07001510 // We close any open folders and shortcut containers that are not safe for rebind,
Sunny Goyal740ac7f2016-09-28 16:47:32 -07001511 // and we need to make sure this state is reflected.
Pinyao Tinga74b63a2019-07-17 23:26:06 -07001512 AbstractFloatingView.closeOpenViews(this, false, TYPE_ALL & ~TYPE_REBIND_SAFE);
1513 finishAutoCancelActionMode();
Tony Wickham49c8d292016-07-01 11:44:34 -07001514
Sunny Goyal2100c782016-08-22 16:00:03 -07001515 if (mPendingRequestArgs != null) {
1516 outState.putParcelable(RUNTIME_STATE_PENDING_REQUEST_ARGS, mPendingRequestArgs);
1517 }
Sunny Goyaldedda052019-05-14 15:23:48 -07001518 outState.putInt(RUNTIME_STATE_PENDING_REQUEST_CODE, mPendingActivityRequestCode);
1519
Sunny Goyal2100c782016-08-22 16:00:03 -07001520 if (mPendingActivityResult != null) {
1521 outState.putParcelable(RUNTIME_STATE_PENDING_ACTIVITY_RESULT, mPendingActivityResult);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001522 }
1523
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001524 super.onSaveInstanceState(outState);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001525 mOverlayManager.onActivitySaveInstanceState(this, outState);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001526 }
1527
1528 @Override
1529 public void onDestroy() {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001530 super.onDestroy();
Sunny Goyale84c5b82019-09-26 17:05:31 -07001531 ACTIVITY_TRACKER.onActivityDestroyed(this);
Romain Guycbb89e42009-06-08 15:52:54 -07001532
Sunny Goyal5d1873a2018-05-08 11:10:44 -07001533 unregisterReceiver(mScreenOffReceiver);
Sunny Goyalaaf7d1d2016-05-17 13:38:54 -07001534 mWorkspace.removeFolderListeners();
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001535 PluginManagerWrapper.INSTANCE.get(this).removePluginListener(this);
Winson Chunge7a03942011-08-05 15:05:12 -07001536
Sunny Goyala7a5bf32020-01-05 15:35:29 +05301537 mModel.removeCallbacks(this);
Sunny Goyal623eddd2018-03-02 12:24:41 -08001538 mRotationHelper.destroy();
Sunny Goyal745bad92016-05-02 10:54:12 -07001539
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001540 try {
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001541 mAppWidgetHost.stopListening();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001542 } catch (NullPointerException ex) {
Joe Onoratoa30ce8e2009-11-11 08:16:49 -08001543 Log.w(TAG, "problem while stopping AppWidgetHost during Launcher destruction", ex);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001544 }
Patrick Dubroy2313eff2011-01-11 20:01:31 -08001545
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001546 TextKeyListener.getInstance().release();
Tony2917a8b2017-07-31 23:29:42 -07001547 clearPendingBinds();
Hyunyoung Song31971a32019-01-27 12:31:12 -08001548 LauncherAppState.getIDP(this).removeOnChangeListener(this);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001549
1550 mOverlayManager.onActivityDestroyed(this);
Winson Chung24ab40c2019-10-30 22:35:09 -07001551 mAppTransitionManager.unregisterRemoteAnimations();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001552 }
1553
Sunny Goyalae502842016-06-17 08:43:56 -07001554 public LauncherAccessibilityDelegate getAccessibilityDelegate() {
1555 return mAccessibilityDelegate;
1556 }
1557
Adam Cohena9cf38f2011-05-02 15:36:58 -07001558 public DragController getDragController() {
1559 return mDragController;
1560 }
1561
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001562 @Override
Sunny Goyal0eca4e22016-07-20 11:43:06 -07001563 public void startActivityForResult(Intent intent, int requestCode, Bundle options) {
Sunny Goyaldedda052019-05-14 15:23:48 -07001564 if (requestCode != -1) {
1565 mPendingActivityRequestCode = requestCode;
1566 }
Sunny Goyal210e1742019-10-17 12:05:38 -07001567 super.startActivityForResult(intent, requestCode, options);
Adam Cohen173f7112015-03-27 15:14:00 -07001568 }
1569
1570 @Override
Sunny Goyaldedda052019-05-14 15:23:48 -07001571 public void startIntentSenderForResult(IntentSender intent, int requestCode,
Adam Cohen173f7112015-03-27 15:14:00 -07001572 Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags, Bundle options) {
Sunny Goyaldedda052019-05-14 15:23:48 -07001573 if (requestCode != -1) {
1574 mPendingActivityRequestCode = requestCode;
1575 }
Sunny Goyal210e1742019-10-17 12:05:38 -07001576 try {
1577 super.startIntentSenderForResult(intent, requestCode,
1578 fillInIntent, flagsMask, flagsValues, extraFlags, options);
1579 } catch (IntentSender.SendIntentException e) {
1580 throw new ActivityNotFoundException();
Adam Cohen173f7112015-03-27 15:14:00 -07001581 }
1582 }
1583
Winson Chung70d72102011-08-12 11:24:35 -07001584 /**
1585 * Indicates that we want global search for this activity by setting the globalSearch
1586 * argument for {@link #startSearch} to true.
1587 */
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001588 @Override
Romain Guycbb89e42009-06-08 15:52:54 -07001589 public void startSearch(String initialQuery, boolean selectInitialQuery,
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001590 Bundle appSearchData, boolean globalSearch) {
1591 if (appSearchData == null) {
1592 appSearchData = new Bundle();
Bjorn Bringert32b12d22013-06-06 13:00:41 +01001593 appSearchData.putString("source", "launcher-search");
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001594 }
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07001595
Sunny Goyal6f28e712016-09-13 14:19:29 -07001596 if (mLauncherCallbacks == null ||
1597 !mLauncherCallbacks.startSearch(initialQuery, selectInitialQuery, appSearchData)) {
1598 // Starting search from the callbacks failed. Start the default global search.
Sunny Goyalf4aceab2017-12-06 16:16:31 -08001599 super.startSearch(initialQuery, selectInitialQuery, appSearchData, true);
Ian Parkinson047036e2014-09-01 15:40:53 +01001600 }
Winson Chungcd99cd32015-04-29 11:03:24 -07001601
1602 // We need to show the workspace after starting the search
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001603 mStateManager.goToState(NORMAL);
Bjorn Bringertc459e522013-06-07 19:36:01 +01001604 }
1605
Joe Onorato9c1289c2009-08-17 11:03:03 -04001606 public boolean isWorkspaceLocked() {
Sunny Goyal2100c782016-08-22 16:00:03 -07001607 return mWorkspaceLoading || mPendingRequestArgs != null;
Joe Onorato9c1289c2009-08-17 11:03:03 -04001608 }
1609
Adam Cohen517a7f52014-03-01 12:12:59 -08001610 public boolean isWorkspaceLoading() {
1611 return mWorkspaceLoading;
1612 }
1613
Anjali Koppalff7ceff2014-05-01 18:26:37 -07001614 private void setWorkspaceLoading(boolean value) {
Anjali Koppalff7ceff2014-05-01 18:26:37 -07001615 mWorkspaceLoading = value;
Anjali Koppalff7ceff2014-05-01 18:26:37 -07001616 }
1617
Sunny Goyal04a324a2017-01-20 21:08:59 -08001618 public void setWaitingForResult(PendingRequestArgs args) {
Sunny Goyal2100c782016-08-22 16:00:03 -07001619 mPendingRequestArgs = args;
Adam Cohen9211d422014-10-07 18:14:53 -07001620 }
Anjali Koppalff7ceff2014-05-01 18:26:37 -07001621
Sunny Goyal2100c782016-08-22 16:00:03 -07001622 void addAppWidgetFromDropImpl(int appWidgetId, ItemInfo info, AppWidgetHostView boundWidget,
Sunny Goyal04a324a2017-01-20 21:08:59 -08001623 WidgetAddFlowHandler addFlowHandler) {
Tony Wickhama0628cc2015-10-14 15:23:04 -07001624 if (LOGD) {
1625 Log.d(TAG, "Adding widget from drop");
1626 }
Sunny Goyal04a324a2017-01-20 21:08:59 -08001627 addAppWidgetImpl(appWidgetId, info, boundWidget, addFlowHandler, 0);
Adam Cohenad4e15c2013-10-17 16:21:35 -07001628 }
1629
Sunny Goyal2100c782016-08-22 16:00:03 -07001630 void addAppWidgetImpl(int appWidgetId, ItemInfo info,
Sunny Goyal04a324a2017-01-20 21:08:59 -08001631 AppWidgetHostView boundWidget, WidgetAddFlowHandler addFlowHandler, int delay) {
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001632 if (!addFlowHandler.startConfigActivity(this, appWidgetId, info,
1633 REQUEST_CREATE_APPWIDGET)) {
Sunny Goyal04a324a2017-01-20 21:08:59 -08001634 // If the configuration flow was not started, add the widget
Michael Jurkaaf442092010-06-10 17:01:57 -07001635
Adam Cohenad4e15c2013-10-17 16:21:35 -07001636 Runnable onComplete = new Runnable() {
1637 @Override
1638 public void run() {
1639 // Exit spring loaded mode if necessary after adding the widget
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001640 mStateManager.goToState(NORMAL, SPRING_LOADED_EXIT_DELAY);
Adam Cohenad4e15c2013-10-17 16:21:35 -07001641 }
1642 };
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001643 completeAddAppWidget(appWidgetId, info, boundWidget,
1644 addFlowHandler.getProviderInfo(this));
Adam Cohen689ff162014-05-08 17:27:56 -07001645 mWorkspace.removeExtraEmptyScreenDelayed(true, onComplete, delay, false);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001646 }
1647 }
Romain Guycbb89e42009-06-08 15:52:54 -07001648
Sunny Goyalefb7e842018-10-04 15:11:00 -07001649 public void addPendingItem(PendingAddItemInfo info, int container, int screenId,
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08001650 int[] cell, int spanX, int spanY) {
Sunny Goyal2100c782016-08-22 16:00:03 -07001651 info.container = container;
1652 info.screenId = screenId;
1653 if (cell != null) {
1654 info.cellX = cell[0];
1655 info.cellY = cell[1];
1656 }
1657 info.spanX = spanX;
1658 info.spanY = spanY;
1659
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08001660 switch (info.itemType) {
1661 case LauncherSettings.Favorites.ITEM_TYPE_CUSTOM_APPWIDGET:
1662 case LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET:
Sunny Goyal2100c782016-08-22 16:00:03 -07001663 addAppWidgetFromDrop((PendingAddWidgetInfo) info);
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08001664 break;
1665 case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT:
Sunny Goyal782f0c92017-01-19 10:27:54 -08001666 processShortcutFromDrop((PendingAddShortcutInfo) info);
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08001667 break;
1668 default:
1669 throw new IllegalStateException("Unknown item type: " + info.itemType);
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001670 }
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08001671 }
1672
Adam Cohenfbba09b2011-07-18 21:43:05 -07001673 /**
1674 * Process a shortcut drop.
Adam Cohenfbba09b2011-07-18 21:43:05 -07001675 */
Sunny Goyal782f0c92017-01-19 10:27:54 -08001676 private void processShortcutFromDrop(PendingAddShortcutInfo info) {
Sunny Goyalfb5096d2016-09-08 14:32:06 -07001677 Intent intent = new Intent(Intent.ACTION_CREATE_SHORTCUT).setComponent(info.componentName);
1678 setWaitingForResult(PendingRequestArgs.forIntent(REQUEST_CREATE_SHORTCUT, intent, info));
Sunny Goyal782f0c92017-01-19 10:27:54 -08001679 if (!info.activityInfo.startConfigActivity(this, REQUEST_CREATE_SHORTCUT)) {
1680 handleActivityResult(REQUEST_CREATE_SHORTCUT, RESULT_CANCELED, null);
1681 }
Michael Jurka0280c3b2010-09-17 15:00:07 -07001682 }
1683
Adam Cohenfbba09b2011-07-18 21:43:05 -07001684 /**
1685 * Process a widget drop.
Adam Cohenfbba09b2011-07-18 21:43:05 -07001686 */
Sunny Goyal2100c782016-08-22 16:00:03 -07001687 private void addAppWidgetFromDrop(PendingAddWidgetInfo info) {
Adam Cohened66b2b2012-01-23 17:28:51 -08001688 AppWidgetHostView hostView = info.boundWidget;
Sunny Goyal952e63d2017-08-16 04:59:08 -07001689 final int appWidgetId;
Sunny Goyal8a0dc382017-01-25 11:30:06 -08001690 WidgetAddFlowHandler addFlowHandler = info.getHandler();
Adam Cohened66b2b2012-01-23 17:28:51 -08001691 if (hostView != null) {
Tony Wickhama0628cc2015-10-14 15:23:04 -07001692 // In the case where we've prebound the widget, we remove it from the DragLayer
1693 if (LOGD) {
1694 Log.d(TAG, "Removing widget view from drag layer and setting boundWidget to null");
1695 }
1696 getDragLayer().removeView(hostView);
1697
Adam Cohened66b2b2012-01-23 17:28:51 -08001698 appWidgetId = hostView.getAppWidgetId();
Sunny Goyal04a324a2017-01-20 21:08:59 -08001699 addAppWidgetFromDropImpl(appWidgetId, info, hostView, addFlowHandler);
Sunny Goyal5b9ebca2015-06-01 18:37:32 -07001700
1701 // Clear the boundWidget so that it doesn't get destroyed.
1702 info.boundWidget = null;
Adam Cohened66b2b2012-01-23 17:28:51 -08001703 } else {
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001704 // In this case, we either need to start an activity to get permission to bind
1705 // the widget, or we need to start an activity to configure the widget, or both.
Pinyao Tingc7a6c292019-08-26 14:36:02 -07001706 if (info.itemType == LauncherSettings.Favorites.ITEM_TYPE_CUSTOM_APPWIDGET) {
1707 appWidgetId = CustomWidgetManager.INSTANCE.get(this).getWidgetIdForCustomProvider(
1708 info.componentName);
Sunny Goyal952e63d2017-08-16 04:59:08 -07001709 } else {
1710 appWidgetId = getAppWidgetHost().allocateAppWidgetId();
1711 }
Adam Cohendd70d662012-10-04 16:53:44 -07001712 Bundle options = info.bindOptions;
1713
Sunny Goyalffe83f12014-08-14 17:39:34 -07001714 boolean success = mAppWidgetManager.bindAppWidgetIdIfAllowed(
1715 appWidgetId, info.info, options);
Adam Cohendd70d662012-10-04 16:53:44 -07001716 if (success) {
Sunny Goyal04a324a2017-01-20 21:08:59 -08001717 addAppWidgetFromDropImpl(appWidgetId, info, null, addFlowHandler);
Michael Jurka8b805b12012-04-18 14:23:14 -07001718 } else {
Sunny Goyal04a324a2017-01-20 21:08:59 -08001719 addFlowHandler.startBindFlow(this, appWidgetId, info, REQUEST_BIND_APPWIDGET);
Michael Jurka8b805b12012-04-18 14:23:14 -07001720 }
Adam Cohened66b2b2012-01-23 17:28:51 -08001721 }
Adam Cohenfbba09b2011-07-18 21:43:05 -07001722 }
1723
Samuel Fufa746d4202020-02-02 18:55:44 -08001724 /**
1725 * Creates and adds new folder to CellLayout
1726 */
Samuel Fufa28c3e452020-02-08 16:07:16 -08001727 public FolderIcon addFolder(CellLayout layout, int container, final int screenId, int cellX,
1728 int cellY) {
Michael Jurkac9d95c52011-08-29 14:03:34 -07001729 final FolderInfo folderInfo = new FolderInfo();
Samuel Fufa84245e82019-08-14 13:44:12 -07001730 folderInfo.title = "";
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001731
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001732 // Update the model
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001733 getModelWriter().addItemToDatabase(folderInfo, container, screenId, cellX, cellY);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001734
1735 // Create the view
Samuel Fufa746d4202020-02-02 18:55:44 -08001736 FolderIcon newFolder = FolderIcon.inflateFolderAndIcon(R.layout.folder_icon, this, layout,
1737 folderInfo);
Sunny Goyald5462aa2016-11-22 16:52:39 +05301738 mWorkspace.addInScreen(newFolder, folderInfo);
Winson Chung5f8afe62013-08-12 16:19:28 -07001739 // Force measure the new folder icon
1740 CellLayout parent = mWorkspace.getParentCellLayoutForView(newFolder);
1741 parent.getShortcutsAndWidgets().measureChild(newFolder);
Adam Cohendf035382011-04-11 17:22:04 -07001742 return newFolder;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001743 }
Romain Guycbb89e42009-06-08 15:52:54 -07001744
Winsonc0b52fe2015-09-09 16:38:15 -07001745 /**
Samuel Fufa28c3e452020-02-08 16:07:16 -08001746 * Called when a workspace item is converted into a folder
1747 */
1748 public void folderCreatedFromItem(Folder folder, WorkspaceItemInfo itemInfo){}
1749
1750 /**
1751 * Called when a folder is converted into a workspace item
1752 */
1753 public void folderConvertedToItem(Folder folder, WorkspaceItemInfo itemInfo) {}
1754
1755 /**
Winsonfa56b3f2015-09-14 12:01:13 -07001756 * Unbinds the view for the specified item, and removes the item and all its children.
1757 *
1758 * @param v the view being removed.
Winsonfa56b3f2015-09-14 12:01:13 -07001759 * @param itemInfo the {@link ItemInfo} for this view.
1760 * @param deleteFromDb whether or not to delete this item from the db.
Winsonc0b52fe2015-09-09 16:38:15 -07001761 */
Tony Wickhambfbf7f92016-05-19 11:19:39 -07001762 public boolean removeItem(View v, final ItemInfo itemInfo, boolean deleteFromDb) {
Sunny Goyal95899162019-03-27 16:03:06 -07001763 if (itemInfo instanceof WorkspaceItemInfo) {
Winsonfa56b3f2015-09-14 12:01:13 -07001764 // Remove the shortcut from the folder before removing it from launcher
Sunny Goyal44c06432016-04-02 10:56:02 -07001765 View folderIcon = mWorkspace.getHomescreenIconByItemId(itemInfo.container);
1766 if (folderIcon instanceof FolderIcon) {
Sunny Goyal95899162019-03-27 16:03:06 -07001767 ((FolderInfo) folderIcon.getTag()).remove((WorkspaceItemInfo) itemInfo, true);
Winsonfa56b3f2015-09-14 12:01:13 -07001768 } else {
1769 mWorkspace.removeWorkspaceItem(v);
1770 }
Winsonc0b52fe2015-09-09 16:38:15 -07001771 if (deleteFromDb) {
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001772 getModelWriter().deleteItemFromDatabase(itemInfo);
Winsonc0b52fe2015-09-09 16:38:15 -07001773 }
1774 } else if (itemInfo instanceof FolderInfo) {
1775 final FolderInfo folderInfo = (FolderInfo) itemInfo;
Sunny Goyalaaf7d1d2016-05-17 13:38:54 -07001776 if (v instanceof FolderIcon) {
1777 ((FolderIcon) v).removeListeners();
1778 }
Winsonc0b52fe2015-09-09 16:38:15 -07001779 mWorkspace.removeWorkspaceItem(v);
1780 if (deleteFromDb) {
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001781 getModelWriter().deleteFolderAndContentsFromDatabase(folderInfo);
Winsonc0b52fe2015-09-09 16:38:15 -07001782 }
1783 } else if (itemInfo instanceof LauncherAppWidgetInfo) {
1784 final LauncherAppWidgetInfo widgetInfo = (LauncherAppWidgetInfo) itemInfo;
Winson44818e02015-10-02 11:25:46 -07001785 mWorkspace.removeWorkspaceItem(v);
Winsonc0b52fe2015-09-09 16:38:15 -07001786 if (deleteFromDb) {
Tony Wickham6a71a5b2018-08-21 11:40:23 -07001787 getModelWriter().deleteWidgetInfo(widgetInfo, getAppWidgetHost());
Winsonc0b52fe2015-09-09 16:38:15 -07001788 }
1789 } else {
1790 return false;
1791 }
1792 return true;
1793 }
1794
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001795 @Override
1796 public boolean dispatchKeyEvent(KeyEvent event) {
vadimtd633c9c2020-01-22 18:00:37 -08001797 TestLogging.recordEvent(TestProtocol.SEQUENCE_MAIN, "Key event", event);
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08001798 return (event.getKeyCode() == KeyEvent.KEYCODE_HOME) || super.dispatchKeyEvent(event);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001799 }
1800
Joe Onorato88ec0992009-11-19 13:16:06 -08001801 @Override
vadimt9af34a72020-01-21 11:19:13 -08001802 public boolean dispatchTouchEvent(MotionEvent ev) {
vadimtd633c9c2020-01-22 18:00:37 -08001803 TestLogging.recordMotionEvent(TestProtocol.SEQUENCE_MAIN, "Touch event", ev);
vadimt9af34a72020-01-21 11:19:13 -08001804 return super.dispatchTouchEvent(ev);
1805 }
1806
1807 @Override
Joe Onorato88ec0992009-11-19 13:16:06 -08001808 public void onBackPressed() {
Sunny Goyal7c8a65e2017-12-22 11:11:33 -08001809 if (finishAutoCancelActionMode()) {
1810 return;
1811 }
Adam Cohen9211d422014-10-07 18:14:53 -07001812
Sunny Goyal45478022015-06-08 16:52:41 -07001813 if (mDragController.isDragging()) {
1814 mDragController.cancelDrag();
Adam Cohenc9735cf2015-01-23 16:11:55 -08001815 return;
1816 }
1817
Jon Mirandafeba90f2016-10-06 10:53:29 -07001818 // Note: There should be at most one log per method call. This is enforced implicitly
1819 // by using if-else statements.
Sunny Goyal740ac7f2016-09-28 16:47:32 -07001820 AbstractFloatingView topView = AbstractFloatingView.getTopOpenView(this);
Tony Wickham52c1b662018-05-21 13:13:58 -07001821 if (topView != null && topView.onBackPressed()) {
1822 // Handled by the floating view.
Patrick Dubroy94f78a52011-02-28 17:39:16 -08001823 } else {
Sunny Goyale39690b2018-08-02 13:35:07 -07001824 mStateManager.getState().onBackPressed(this);
Michael Jurkaaf442092010-06-10 17:01:57 -07001825 }
Joe Onorato88ec0992009-11-19 13:16:06 -08001826 }
1827
Sunny Goyalfe770c92016-09-27 14:38:58 -07001828 @TargetApi(Build.VERSION_CODES.M)
Sunny Goyal0b0847b2018-03-14 12:30:11 -07001829 @Override
Jon Miranda73c27ec2018-05-16 18:06:23 -07001830 public ActivityOptions getActivityLaunchOptions(View v) {
1831 return mAppTransitionManager.getActivityLaunchOptions(this, v);
Sunny Goyala7ce1662016-05-31 15:01:35 -07001832 }
1833
Tony Wickham3a6746a2018-03-29 09:39:56 -07001834 public LauncherAppTransitionManager getAppTransitionManager() {
1835 return mAppTransitionManager;
1836 }
1837
Sunny Goyal0b0847b2018-03-14 12:30:11 -07001838 @TargetApi(Build.VERSION_CODES.M)
1839 @Override
1840 protected boolean onErrorStartingShortcut(Intent intent, ItemInfo info) {
1841 // Due to legacy reasons, direct call shortcuts require Launchers to have the
1842 // corresponding permission. Show the appropriate permission prompt if that
1843 // is the case.
1844 if (intent.getComponent() == null
1845 && Intent.ACTION_CALL.equals(intent.getAction())
1846 && checkSelfPermission(android.Manifest.permission.CALL_PHONE) !=
1847 PackageManager.PERMISSION_GRANTED) {
1848
1849 setWaitingForResult(PendingRequestArgs
1850 .forIntent(REQUEST_PERMISSION_CALL_PHONE, intent, info));
1851 requestPermissions(new String[]{android.Manifest.permission.CALL_PHONE},
1852 REQUEST_PERMISSION_CALL_PHONE);
1853 return true;
1854 } else {
1855 return false;
1856 }
Sunny Goyal0eca4e22016-07-20 11:43:06 -07001857 }
1858
Hyunyoung Song46d07f72018-05-22 15:41:25 -07001859 @Override
Hyunyoung Songfc007472018-10-25 14:09:50 -07001860 public int getCurrentState() {
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001861 if (mStateManager.getState() == LauncherState.ALL_APPS) {
Hyunyoung Songfc007472018-10-25 14:09:50 -07001862 return StatsLogUtils.LAUNCHER_STATE_ALLAPPS;
Govinda Wassermanc06e1512019-04-09 09:56:53 -04001863 } else if (mStateManager.getState() == OVERVIEW) {
Hyunyoung Songfc007472018-10-25 14:09:50 -07001864 return StatsLogUtils.LAUNCHER_STATE_OVERVIEW;
1865 }
Hyunyoung Song0ae38882018-11-05 14:45:19 -08001866 return StatsLogUtils.LAUNCHER_STATE_HOME;
Hyunyoung Songfc007472018-10-25 14:09:50 -07001867 }
1868
1869 @Override
Hyunyoung Song46d07f72018-05-22 15:41:25 -07001870 public void modifyUserEvent(LauncherLogProto.LauncherEvent event) {
1871 if (event.srcTarget != null && event.srcTarget.length > 0 &&
1872 event.srcTarget[1].containerType == ContainerType.PREDICTION) {
1873 Target[] targets = new Target[3];
1874 targets[0] = event.srcTarget[0];
1875 targets[1] = event.srcTarget[1];
1876 targets[2] = newTarget(Target.Type.CONTAINER);
1877 event.srcTarget = targets;
1878 LauncherState state = mStateManager.getState();
1879 if (state == LauncherState.ALL_APPS) {
1880 event.srcTarget[2].containerType = ContainerType.ALLAPPS;
Govinda Wassermanc06e1512019-04-09 09:56:53 -04001881 } else if (state == OVERVIEW) {
Hyunyoung Song46d07f72018-05-22 15:41:25 -07001882 event.srcTarget[2].containerType = ContainerType.TASKSWITCHER;
1883 }
1884 }
1885 }
1886
Sunny Goyal9c2b9602020-01-07 13:07:55 -08001887 @Override
Sunny Goyal369212a2019-03-26 15:03:57 -07001888 public boolean startActivitySafely(View v, Intent intent, ItemInfo item,
1889 @Nullable String sourceContainer) {
Winson Chung0b70cd42019-06-17 22:34:33 -07001890 if (!hasBeenResumed()) {
1891 // Workaround an issue where the WM launch animation is clobbered when finishing the
1892 // recents animation into launcher. Defer launching the activity until Launcher is
1893 // next resumed.
1894 addOnResumeCallback(() -> startActivitySafely(v, intent, item, sourceContainer));
Winson Chungc9bf6d42019-10-04 15:33:18 -07001895 if (mOnDeferredActivityLaunchCallback != null) {
1896 mOnDeferredActivityLaunchCallback.run();
1897 mOnDeferredActivityLaunchCallback = null;
1898 }
Winson Chung0b70cd42019-06-17 22:34:33 -07001899 return true;
1900 }
1901
Sunny Goyal369212a2019-03-26 15:03:57 -07001902 boolean success = super.startActivitySafely(v, intent, item, sourceContainer);
Hyunyoung Song1241e612018-05-15 21:46:51 -07001903 if (success && v instanceof BubbleTextView) {
Sunny Goyal0b0847b2018-03-14 12:30:11 -07001904 // This is set to the view that launched the activity that navigated the user away
1905 // from launcher. Since there is no callback for when the activity has finished
1906 // launching, enable the press state and keep this reference to reset the press
1907 // state when we return to launcher.
1908 BubbleTextView btv = (BubbleTextView) v;
1909 btv.setStayPressed(true);
Winson Chung0b70cd42019-06-17 22:34:33 -07001910 addOnResumeCallback(btv);
Sunny Goyala7ce1662016-05-31 15:01:35 -07001911 }
Hyunyoung Song1241e612018-05-15 21:46:51 -07001912 return success;
Michael Jurka86a720e2012-05-09 11:23:23 -07001913 }
1914
Winson Chung3d503fb2011-07-13 17:25:49 -07001915 boolean isHotseatLayout(View layout) {
Sunny Goyalc13403c2016-11-18 23:44:48 -08001916 // TODO: Remove this method
Sunny Goyal876e4622018-11-02 13:50:40 -07001917 return mHotseat != null && (layout == mHotseat);
Winson Chung3d503fb2011-07-13 17:25:49 -07001918 }
Romain Guy1fbc1c82009-11-09 20:43:08 -08001919
Winson Chung3d503fb2011-07-13 17:25:49 -07001920 /**
1921 * Returns the CellLayout of the specified container at the specified screen.
1922 */
Sunny Goyalefb7e842018-10-04 15:11:00 -07001923 public CellLayout getCellLayout(int container, int screenId) {
Sunny Goyal876e4622018-11-02 13:50:40 -07001924 return (container == LauncherSettings.Favorites.CONTAINER_HOTSEAT)
1925 ? mHotseat : mWorkspace.getScreenWithId(screenId);
Romain Guya6abce82009-11-10 02:54:41 -08001926 }
1927
Michael Jurkae326f182011-11-21 14:05:46 -08001928 @Override
1929 public void onTrimMemory(int level) {
1930 super.onTrimMemory(level);
Adam Cohen3f9c9712014-10-31 11:48:25 -07001931 if (level >= ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN) {
1932 // The widget preview db can result in holding onto over
1933 // 3MB of memory for caching which isn't necessary.
1934 SQLiteDatabase.releaseMemory();
1935
Adam Cohenc8f4e1b2014-11-19 16:03:20 -08001936 // This clears all widget bitmaps from the widget tray
Hyunyoung Song3f471442015-04-08 19:01:34 -07001937 // TODO(hyunyoungs)
Michael Jurkae326f182011-11-21 14:05:46 -08001938 }
1939 }
1940
Michael Jurkad7c28052012-04-27 15:43:36 -07001941 @Override
1942 public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
alanv1d4fde62012-10-17 13:15:47 -07001943 final boolean result = super.dispatchPopulateAccessibilityEvent(event);
Michael Jurkad7c28052012-04-27 15:43:36 -07001944 final List<CharSequence> text = event.getText();
1945 text.clear();
alanv1d4fde62012-10-17 13:15:47 -07001946 // Populate event with a fake title based on the current state.
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001947 // TODO: When can workspace be null?
1948 text.add(mWorkspace == null
1949 ? getString(R.string.all_apps_home_button_label)
Sunny Goyalea609262017-10-25 15:47:38 -07001950 : mStateManager.getState().getDescription(this));
Michael Jurkad7c28052012-04-27 15:43:36 -07001951 return result;
1952 }
1953
Winson Chung0b70cd42019-06-17 22:34:33 -07001954 public void addOnResumeCallback(OnResumeCallback callback) {
1955 mOnResumeCallbacks.add(callback);
Michael Jurka1e2f4652013-07-08 18:03:46 -07001956 }
1957
Michael Jurka7607c2f2013-04-03 14:33:19 -07001958 /**
Winson Chungc9bf6d42019-10-04 15:33:18 -07001959 * Persistant callback which notifies when an activity launch is deferred because the activity
1960 * was not yet resumed.
1961 */
1962 public void setOnDeferredActivityLaunchCallback(Runnable callback) {
1963 mOnDeferredActivityLaunchCallback = callback;
1964 }
1965
1966 /**
Sunny Goyala7a5bf32020-01-05 15:35:29 +05301967 * Sets the next page to bind synchronously on next bind.
1968 * @param page
1969 */
1970 public void setPageToBindSynchronously(int page) {
1971 mPageToBindSynchronously = page;
1972 }
1973
1974 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04001975 * Implementation of the method from LauncherModel.Callbacks.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001976 */
Sunny Goyal93f878c2016-03-30 17:31:24 -07001977 @Override
Sunny Goyala7a5bf32020-01-05 15:35:29 +05301978 public int getPageToBindSynchronously() {
1979 if (mPageToBindSynchronously != PagedView.INVALID_PAGE) {
1980 return mPageToBindSynchronously;
1981 } else if (mWorkspace != null) {
Michael Jurka0142d492010-08-25 17:46:15 -07001982 return mWorkspace.getCurrentPage();
Joe Onoratod0afc872010-06-11 00:03:15 -07001983 } else {
Winson Chung882a52e2015-07-08 14:32:26 -07001984 return 0;
Joe Onoratod0afc872010-06-11 00:03:15 -07001985 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04001986 }
The Android Open Source Projectf96811c2009-03-18 17:39:48 -07001987
Joe Onorato9c1289c2009-08-17 11:03:03 -04001988 /**
Sunny Goyal527c7d32015-08-28 15:19:36 -07001989 * Clear any pending bind callbacks. This is called when is loader is planning to
1990 * perform a full rebind from scratch.
1991 */
1992 @Override
1993 public void clearPendingBinds() {
Sunny Goyal527c7d32015-08-28 15:19:36 -07001994 if (mPendingExecutor != null) {
1995 mPendingExecutor.markCompleted();
1996 mPendingExecutor = null;
Sunny Goyal6b6d0a32019-08-05 17:19:32 -07001997
1998 // We might have set this flag previously and forgot to clear it.
1999 mAppsView.getAppsStore()
2000 .disableDeferUpdatesSilently(AllAppsStore.DEFER_UPDATES_NEXT_DRAW);
Sunny Goyal527c7d32015-08-28 15:19:36 -07002001 }
2002 }
2003
2004 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04002005 * Refreshes the shortcuts shown on the workspace.
2006 *
2007 * Implementation of the method from LauncherModel.Callbacks.
2008 */
2009 public void startBinding() {
Winson Chung5cc62c72019-10-16 11:32:41 -07002010 Object traceToken = TraceHelper.INSTANCE.beginSection("startBinding");
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07002011 // Floating panels (except the full widget sheet) are associated with individual icons. If
2012 // we are starting a fresh bind, close all such panels as all the icons are about
2013 // to go away.
Pinyao Tinga74b63a2019-07-17 23:26:06 -07002014 AbstractFloatingView.closeOpenViews(this, true, TYPE_ALL & ~TYPE_REBIND_SAFE);
Jon Miranda6dc7f1e2017-02-21 12:37:51 -08002015
Anjali Koppalff7ceff2014-05-01 18:26:37 -07002016 setWorkspaceLoading(true);
Adam Cohen517a7f52014-03-01 12:12:59 -08002017
Winson Chungd64d1762013-08-20 14:37:16 -07002018 // Clear the workspace because it's going to be rebound
Sunny Goyal2db53422019-03-01 16:06:12 -08002019 mDragController.cancelDrag();
2020
Adam Cohendf035382011-04-11 17:22:04 -07002021 mWorkspace.clearDropTargets();
Winson Chung9e6a0a22013-08-27 11:58:12 -07002022 mWorkspace.removeAllWorkspaceScreens();
Sunny Goyalc11fac32018-02-27 19:20:15 -08002023 mAppWidgetHost.clearViews();
Winson Chungd64d1762013-08-20 14:37:16 -07002024
Winson Chung3d503fb2011-07-13 17:25:49 -07002025 if (mHotseat != null) {
Sunny Goyalae6e3182019-04-30 12:04:37 -07002026 mHotseat.resetLayout(getWallpaperDeviceProfile().isVerticalBarLayout());
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002027 }
Winson Chung5cc62c72019-10-16 11:32:41 -07002028 TraceHelper.INSTANCE.endSection(traceToken);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002029 }
2030
Adam Cohendcd297f2013-06-18 13:13:40 -07002031 @Override
Sunny Goyalefb7e842018-10-04 15:11:00 -07002032 public void bindScreens(IntArray orderedScreenIds) {
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002033 // Make sure the first screen is always at the start.
Jon Miranda7143ba62019-03-15 09:00:05 -07002034 if (FeatureFlags.QSB_ON_FIRST_SCREEN &&
Sunny Goyala9e2f5a2016-06-10 12:22:04 -07002035 orderedScreenIds.indexOf(Workspace.FIRST_SCREEN_ID) != 0) {
Sunny Goyalefb7e842018-10-04 15:11:00 -07002036 orderedScreenIds.removeValue(Workspace.FIRST_SCREEN_ID);
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002037 orderedScreenIds.add(0, Workspace.FIRST_SCREEN_ID);
Jon Miranda7143ba62019-03-15 09:00:05 -07002038 } else if (!FeatureFlags.QSB_ON_FIRST_SCREEN && orderedScreenIds.isEmpty()) {
Sunny Goyala9e2f5a2016-06-10 12:22:04 -07002039 // If there are no screens, we need to have an empty screen
2040 mWorkspace.addExtraEmptyScreen();
Adam Cohen5084cba2013-09-03 12:01:16 -07002041 }
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002042 bindAddScreens(orderedScreenIds);
Winson Chung0e6a7132013-08-23 12:55:10 -07002043
Winsonc7d2e832016-07-28 12:24:55 -07002044 // After we have added all the screens, if the wallpaper was locked to the default state,
2045 // then notify to indicate that it can be released and a proper wallpaper offset can be
2046 // computed before the next layout
2047 mWorkspace.unlockWallpaperFromDefaultPageOnNextLayout();
Winson Chung64359a52013-07-08 17:17:08 -07002048 }
2049
Sunny Goyalefb7e842018-10-04 15:11:00 -07002050 private void bindAddScreens(IntArray orderedScreenIds) {
Adam Cohendcd297f2013-06-18 13:13:40 -07002051 int count = orderedScreenIds.size();
2052 for (int i = 0; i < count; i++) {
Sunny Goyalefb7e842018-10-04 15:11:00 -07002053 int screenId = orderedScreenIds.get(i);
Jon Miranda7143ba62019-03-15 09:00:05 -07002054 if (!FeatureFlags.QSB_ON_FIRST_SCREEN || screenId != Workspace.FIRST_SCREEN_ID) {
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002055 // No need to bind the first screen, as its always bound.
2056 mWorkspace.insertNewWorkspaceScreenBeforeEmptyScreen(screenId);
2057 }
Adam Cohendcd297f2013-06-18 13:13:40 -07002058 }
Adam Cohendcd297f2013-06-18 13:13:40 -07002059 }
2060
Sunny Goyalb23980c2017-08-17 07:45:25 -07002061 @Override
Tony Wickham6a71a5b2018-08-21 11:40:23 -07002062 public void preAddApps() {
2063 // If there's an undo snackbar, force it to complete to ensure empty screens are removed
2064 // before trying to add new items.
2065 mModelWriter.commitDelete();
2066 AbstractFloatingView snackbar = AbstractFloatingView.getOpenView(this, TYPE_SNACKBAR);
2067 if (snackbar != null) {
2068 snackbar.post(() -> snackbar.close(true));
2069 }
2070 }
2071
2072 @Override
Sunny Goyalefb7e842018-10-04 15:11:00 -07002073 public void bindAppsAdded(IntArray newScreens, ArrayList<ItemInfo> addNotAnimated,
Sunny Goyal29947f02017-12-18 13:49:44 -08002074 ArrayList<ItemInfo> addAnimated) {
Winson Chungd64d1762013-08-20 14:37:16 -07002075 // Add the new screens
Adam Cohen76a47a12014-02-05 11:47:43 -08002076 if (newScreens != null) {
2077 bindAddScreens(newScreens);
2078 }
Winson Chungd64d1762013-08-20 14:37:16 -07002079
2080 // We add the items without animation on non-visible pages, and with
2081 // animations on the new page (which we will try and snap to).
Adam Cohen76a47a12014-02-05 11:47:43 -08002082 if (addNotAnimated != null && !addNotAnimated.isEmpty()) {
Sunny Goyalb23980c2017-08-17 07:45:25 -07002083 bindItems(addNotAnimated, false);
Winson Chungd64d1762013-08-20 14:37:16 -07002084 }
Adam Cohen76a47a12014-02-05 11:47:43 -08002085 if (addAnimated != null && !addAnimated.isEmpty()) {
Sunny Goyalb23980c2017-08-17 07:45:25 -07002086 bindItems(addAnimated, true);
Winson Chungd64d1762013-08-20 14:37:16 -07002087 }
Winson Chungc58497e2013-09-03 17:48:37 -07002088
Winson Chung87412982013-10-03 18:34:14 -07002089 // Remove the extra empty screen
Adam Cohen689ff162014-05-08 17:27:56 -07002090 mWorkspace.removeExtraEmptyScreen(false, false);
Winson Chungd64d1762013-08-20 14:37:16 -07002091 }
2092
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002093 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04002094 * Bind the items start-end from the list.
2095 *
2096 * Implementation of the method from LauncherModel.Callbacks.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002097 */
Tony Wickham0bb211a2015-10-02 16:22:08 -07002098 @Override
Sunny Goyalb23980c2017-08-17 07:45:25 -07002099 public void bindItems(final List<ItemInfo> items, final boolean forceAnimateIcons) {
Sunny Goyal3be633b2016-12-08 09:59:25 -08002100 // Get the list of added items and intersect them with the set of items here
Rajeev Kumar43c0f582017-06-23 15:34:55 -07002101 final Collection<Animator> bounceAnims = new ArrayList<>();
Winson Chung997a9232013-07-24 15:33:46 -07002102 final boolean animateIcons = forceAnimateIcons && canRunNewAppsAnimation();
Winson Chungf0c6ae02012-03-21 16:10:31 -07002103 Workspace workspace = mWorkspace;
Sunny Goyalefb7e842018-10-04 15:11:00 -07002104 int newItemsScreenId = -1;
Sunny Goyalb23980c2017-08-17 07:45:25 -07002105 int end = items.size();
2106 for (int i = 0; i < end; i++) {
Sunny Goyal3be633b2016-12-08 09:59:25 -08002107 final ItemInfo item = items.get(i);
Winson Chung4d279d92011-07-21 11:46:32 -07002108
2109 // Short circuit if we are loading dock items for a configuration which has no dock
2110 if (item.container == LauncherSettings.Favorites.CONTAINER_HOTSEAT &&
2111 mHotseat == null) {
2112 continue;
2113 }
2114
Sunny Goyal639e9062015-08-19 19:17:06 -07002115 final View view;
Joe Onorato9c1289c2009-08-17 11:03:03 -04002116 switch (item.itemType) {
2117 case LauncherSettings.Favorites.ITEM_TYPE_APPLICATION:
2118 case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT:
Sunny Goyal3be633b2016-12-08 09:59:25 -08002119 case LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT: {
Sunny Goyal95899162019-03-27 16:03:06 -07002120 WorkspaceItemInfo info = (WorkspaceItemInfo) item;
Sunny Goyal639e9062015-08-19 19:17:06 -07002121 view = createShortcut(info);
Joe Onorato9c1289c2009-08-17 11:03:03 -04002122 break;
Sunny Goyal3be633b2016-12-08 09:59:25 -08002123 }
2124 case LauncherSettings.Favorites.ITEM_TYPE_FOLDER: {
Tracy Zhou4d7b2442019-12-09 13:42:57 -08002125 view = FolderIcon.inflateFolderAndIcon(R.layout.folder_icon, this,
Michael Jurka0142d492010-08-25 17:46:15 -07002126 (ViewGroup) workspace.getChildAt(workspace.getCurrentPage()),
Sunny Goyal1cd01b02016-11-09 10:43:58 -08002127 (FolderInfo) item);
Joe Onorato9c1289c2009-08-17 11:03:03 -04002128 break;
Sunny Goyal3be633b2016-12-08 09:59:25 -08002129 }
Sunny Goyal952e63d2017-08-16 04:59:08 -07002130 case LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET:
2131 case LauncherSettings.Favorites.ITEM_TYPE_CUSTOM_APPWIDGET: {
Sunny Goyala9a1a212017-08-18 01:03:21 -07002132 view = inflateAppWidget((LauncherAppWidgetInfo) item);
Sunny Goyalb23980c2017-08-17 07:45:25 -07002133 if (view == null) {
2134 continue;
Sunny Goyal3be633b2016-12-08 09:59:25 -08002135 }
Sunny Goyal3be633b2016-12-08 09:59:25 -08002136 break;
2137 }
Winson Chungc763c4e2013-07-19 13:49:06 -07002138 default:
2139 throw new RuntimeException("Invalid Item Type");
Joe Onorato9c1289c2009-08-17 11:03:03 -04002140 }
Sunny Goyal639e9062015-08-19 19:17:06 -07002141
Samuel Fufaca37b8a2019-08-19 17:04:36 -07002142 /*
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002143 * Remove colliding items.
2144 */
2145 if (item.container == LauncherSettings.Favorites.CONTAINER_DESKTOP) {
2146 CellLayout cl = mWorkspace.getScreenWithId(item.screenId);
2147 if (cl != null && cl.isOccupied(item.cellX, item.cellY)) {
2148 View v = cl.getChildAt(item.cellX, item.cellY);
2149 Object tag = v.getTag();
2150 String desc = "Collision while binding workspace item: " + item
2151 + ". Collides with " + tag;
Zak Cohen3eeb41d2020-02-14 14:15:13 -08002152 if (FeatureFlags.IS_STUDIO_BUILD) {
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002153 throw (new RuntimeException(desc));
2154 } else {
2155 Log.d(TAG, desc);
Sunny Goyal43bf11d2017-02-02 13:52:53 -08002156 getModelWriter().deleteItemFromDatabase(item);
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002157 continue;
2158 }
2159 }
2160 }
Sunny Goyald5462aa2016-11-22 16:52:39 +05302161 workspace.addInScreenFromBind(view, item);
Sunny Goyal639e9062015-08-19 19:17:06 -07002162 if (animateIcons) {
2163 // Animate all the applications up now
2164 view.setAlpha(0f);
2165 view.setScaleX(0f);
2166 view.setScaleY(0f);
2167 bounceAnims.add(createNewAppBounceAnimation(view, i));
Sunny Goyal3be633b2016-12-08 09:59:25 -08002168 newItemsScreenId = item.screenId;
Sunny Goyal639e9062015-08-19 19:17:06 -07002169 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002170 }
Winson Chungf0c6ae02012-03-21 16:10:31 -07002171
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002172 // Animate to the correct page
2173 if (animateIcons && newItemsScreenId > -1) {
2174 AnimatorSet anim = new AnimatorSet();
2175 anim.playTogether(bounceAnims);
Jon Miranda64eb8ea2018-03-29 11:43:58 -07002176
Sunny Goyalefb7e842018-10-04 15:11:00 -07002177 int currentScreenId = mWorkspace.getScreenIdForPageIndex(mWorkspace.getNextPage());
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002178 final int newScreenIndex = mWorkspace.getPageIndexForScreenId(newItemsScreenId);
2179 final Runnable startBounceAnimRunnable = anim::start;
2180
2181 if (newItemsScreenId != currentScreenId) {
2182 // We post the animation slightly delayed to prevent slowdowns
2183 // when we are loading right after we return to launcher.
2184 mWorkspace.postDelayed(new Runnable() {
2185 public void run() {
2186 if (mWorkspace != null) {
2187 AbstractFloatingView.closeAllOpenViews(Launcher.this, false);
2188
2189 mWorkspace.snapToPage(newScreenIndex);
2190 mWorkspace.postDelayed(startBounceAnimRunnable,
2191 NEW_APPS_ANIMATION_DELAY);
Winson Chung94d67682013-09-25 16:29:40 -07002192 }
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002193 }
2194 }, NEW_APPS_PAGE_MOVE_DELAY);
2195 } else {
2196 mWorkspace.postDelayed(startBounceAnimRunnable, NEW_APPS_ANIMATION_DELAY);
Winson Chung997a9232013-07-24 15:33:46 -07002197 }
Winson Chung64359a52013-07-08 17:17:08 -07002198 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04002199 workspace.requestLayout();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002200 }
2201
Joe Onorato9c1289c2009-08-17 11:03:03 -04002202 /**
2203 * Add the views for a widget to the workspace.
Joe Onorato9c1289c2009-08-17 11:03:03 -04002204 */
Sunny Goyala9a1a212017-08-18 01:03:21 -07002205 public void bindAppWidget(LauncherAppWidgetInfo item) {
2206 View view = inflateAppWidget(item);
2207 if (view != null) {
2208 mWorkspace.addInScreen(view, item);
2209 mWorkspace.requestLayout();
2210 }
2211 }
2212
2213 private View inflateAppWidget(LauncherAppWidgetInfo item) {
Samuel Fufaca37b8a2019-08-19 17:04:36 -07002214 if (item.hasOptionFlag(LauncherAppWidgetInfo.OPTION_SEARCH_WIDGET)) {
2215 item.providerName = QsbContainerView.getSearchComponentName(this);
2216 if (item.providerName == null) {
2217 getModelWriter().deleteItemFromDatabase(item);
2218 return null;
2219 }
2220 }
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002221 final AppWidgetHostView view;
Sunny Goyal2e1efb42016-03-03 16:58:55 -08002222 if (mIsSafeModeEnabled) {
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002223 view = new PendingAppWidgetHostView(this, item, mIconCache, true);
Sunny Goyald5462aa2016-11-22 16:52:39 +05302224 prepareAppWidget(view, item);
Sunny Goyalb23980c2017-08-17 07:45:25 -07002225 return view;
Sunny Goyal2e1efb42016-03-03 16:58:55 -08002226 }
2227
Winson Chung5cc62c72019-10-16 11:32:41 -07002228 Object traceToken = TraceHelper.INSTANCE.beginSection("BIND_WIDGET_id=" + item.appWidgetId);
Joe Onorato9c1289c2009-08-17 11:03:03 -04002229
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002230 try {
2231 final LauncherAppWidgetProviderInfo appWidgetInfo;
Adam Cohen59400422014-03-05 18:07:04 -08002232
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002233 if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY)) {
2234 // If the provider is not ready, bind as a pending widget.
2235 appWidgetInfo = null;
2236 } else if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)) {
2237 // The widget id is not valid. Try to find the widget based on the provider info.
2238 appWidgetInfo = mAppWidgetManager.findProvider(item.providerName, item.user);
2239 } else {
2240 appWidgetInfo = mAppWidgetManager.getLauncherAppWidgetInfo(item.appWidgetId);
Sunny Goyalff572272014-07-23 13:58:07 -07002241 }
Sunny Goyalff572272014-07-23 13:58:07 -07002242
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002243 // If the provider is ready, but the width is not yet restored, try to restore it.
2244 if (!item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY)
2245 && (item.restoreStatus != LauncherAppWidgetInfo.RESTORE_COMPLETED)) {
2246 if (appWidgetInfo == null) {
2247 Log.d(TAG, "Removing restored widget: id=" + item.appWidgetId
2248 + " belongs to component " + item.providerName
2249 + ", as the provider is null");
2250 getModelWriter().deleteItemFromDatabase(item);
2251 return null;
2252 }
Sunny Goyalff572272014-07-23 13:58:07 -07002253
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002254 // If we do not have a valid id, try to bind an id.
2255 if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)) {
2256 if (!item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_ALLOCATED)) {
2257 // Id has not been allocated yet. Allocate a new id.
2258 item.appWidgetId = mAppWidgetHost.allocateAppWidgetId();
2259 item.restoreStatus |= LauncherAppWidgetInfo.FLAG_ID_ALLOCATED;
Sunny Goyal86df1382016-08-10 15:03:22 -07002260
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002261 // Also try to bind the widget. If the bind fails, the user will be shown
2262 // a click to setup UI, which will ask for the bind permission.
2263 PendingAddWidgetInfo pendingInfo = new PendingAddWidgetInfo(appWidgetInfo);
2264 pendingInfo.spanX = item.spanX;
2265 pendingInfo.spanY = item.spanY;
2266 pendingInfo.minSpanX = item.minSpanX;
2267 pendingInfo.minSpanY = item.minSpanY;
2268 Bundle options = WidgetHostViewLoader.getDefaultOptionsForWidget(this,
2269 pendingInfo);
2270
2271 boolean isDirectConfig =
2272 item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_DIRECT_CONFIG);
2273 if (isDirectConfig && item.bindOptions != null) {
2274 Bundle newOptions = item.bindOptions.getExtras();
2275 if (options != null) {
2276 newOptions.putAll(options);
2277 }
2278 options = newOptions;
Sunny Goyal86df1382016-08-10 15:03:22 -07002279 }
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002280 boolean success = mAppWidgetManager.bindAppWidgetIdIfAllowed(
2281 item.appWidgetId, appWidgetInfo, options);
2282
2283 // We tried to bind once. If we were not able to bind, we would need to
2284 // go through the permission dialog, which means we cannot skip the config
2285 // activity.
2286 item.bindOptions = null;
2287 item.restoreStatus &= ~LauncherAppWidgetInfo.FLAG_DIRECT_CONFIG;
2288
2289 // Bind succeeded
2290 if (success) {
2291 // If the widget has a configure activity, it is still needs to set it
2292 // up, otherwise the widget is ready to go.
2293 item.restoreStatus = (appWidgetInfo.configure == null) || isDirectConfig
2294 ? LauncherAppWidgetInfo.RESTORE_COMPLETED
2295 : LauncherAppWidgetInfo.FLAG_UI_NOT_READY;
2296 }
2297
2298 getModelWriter().updateItemInDatabase(item);
Sunny Goyal86df1382016-08-10 15:03:22 -07002299 }
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002300 } else if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_UI_NOT_READY)
2301 && (appWidgetInfo.configure == null)) {
2302 // The widget was marked as UI not ready, but there is no configure activity to
2303 // update the UI.
2304 item.restoreStatus = LauncherAppWidgetInfo.RESTORE_COMPLETED;
Sunny Goyal43bf11d2017-02-02 13:52:53 -08002305 getModelWriter().updateItemInDatabase(item);
Sunny Goyalff572272014-07-23 13:58:07 -07002306 }
Samuel Fufa9151c012020-02-24 17:06:28 -08002307 else if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_UI_NOT_READY)
2308 && appWidgetInfo.configure != null) {
2309 if (mAppWidgetManager.isAppWidgetRestored(item.appWidgetId)) {
2310 item.restoreStatus = LauncherAppWidgetInfo.RESTORE_COMPLETED;
2311 getModelWriter().updateItemInDatabase(item);
2312 }
2313 }
Sunny Goyal56c73602015-09-25 12:55:01 -07002314 }
2315
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002316 if (item.restoreStatus == LauncherAppWidgetInfo.RESTORE_COMPLETED) {
2317 // Verify that we own the widget
2318 if (appWidgetInfo == null) {
2319 FileLog.e(TAG, "Removing invalid widget: id=" + item.appWidgetId);
2320 getModelWriter().deleteWidgetInfo(item, getAppWidgetHost());
2321 return null;
2322 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04002323
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002324 item.minSpanX = appWidgetInfo.minSpanX;
2325 item.minSpanY = appWidgetInfo.minSpanY;
2326 view = mAppWidgetHost.createView(this, item.appWidgetId, appWidgetInfo);
Samuel Fufa9151c012020-02-24 17:06:28 -08002327 } else if (!item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)
2328 && appWidgetInfo != null) {
2329 mAppWidgetHost.addPendingView(item.appWidgetId,
2330 new PendingAppWidgetHostView(this, item, mIconCache, false));
2331 view = mAppWidgetHost.createView(this, item.appWidgetId, appWidgetInfo);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002332 } else {
2333 view = new PendingAppWidgetHostView(this, item, mIconCache, false);
2334 }
2335 prepareAppWidget(view, item);
2336 } finally {
Winson Chung5cc62c72019-10-16 11:32:41 -07002337 TraceHelper.INSTANCE.endSection(traceToken);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002338 }
2339
Sunny Goyalb23980c2017-08-17 07:45:25 -07002340 return view;
Joe Onorato9c1289c2009-08-17 11:03:03 -04002341 }
2342
Sunny Goyalff572272014-07-23 13:58:07 -07002343 /**
2344 * Restores a pending widget.
2345 *
2346 * @param appWidgetId The app widget id
Sunny Goyalff572272014-07-23 13:58:07 -07002347 */
Sunny Goyald478c832016-04-01 12:04:16 -07002348 private LauncherAppWidgetInfo completeRestoreAppWidget(int appWidgetId, int finalRestoreFlag) {
Sunny Goyalff572272014-07-23 13:58:07 -07002349 LauncherAppWidgetHostView view = mWorkspace.getWidgetForAppWidgetId(appWidgetId);
2350 if ((view == null) || !(view instanceof PendingAppWidgetHostView)) {
2351 Log.e(TAG, "Widget update called, when the widget no longer exists.");
Sunny Goyald478c832016-04-01 12:04:16 -07002352 return null;
Sunny Goyalff572272014-07-23 13:58:07 -07002353 }
2354
Sunny Goyal0fc1be12014-08-11 17:05:23 -07002355 LauncherAppWidgetInfo info = (LauncherAppWidgetInfo) view.getTag();
Sunny Goyald478c832016-04-01 12:04:16 -07002356 info.restoreStatus = finalRestoreFlag;
Jon Miranda2b823f42017-05-02 18:36:18 -07002357 if (info.restoreStatus == LauncherAppWidgetInfo.RESTORE_COMPLETED) {
2358 info.pendingItemInfo = null;
2359 }
Sunny Goyalff572272014-07-23 13:58:07 -07002360
Sunny Goyalba47faa2017-10-04 16:50:57 -07002361 if (((PendingAppWidgetHostView) view).isReinflateIfNeeded()) {
Sunny Goyal29947f02017-12-18 13:49:44 -08002362 view.reInflate();
Sunny Goyalba47faa2017-10-04 16:50:57 -07002363 }
2364
Sunny Goyal43bf11d2017-02-02 13:52:53 -08002365 getModelWriter().updateItemInDatabase(info);
Sunny Goyald478c832016-04-01 12:04:16 -07002366 return info;
Sunny Goyalff572272014-07-23 13:58:07 -07002367 }
2368
Adam Cohen1462de32012-07-24 22:34:36 -07002369 public void onPageBoundSynchronously(int page) {
Sunny Goyalf4aceab2017-12-06 16:16:31 -08002370 mSynchronouslyBoundPage = page;
Sunny Goyala7a5bf32020-01-05 15:35:29 +05302371 mWorkspace.setCurrentPage(page);
2372 mPageToBindSynchronously = PagedView.INVALID_PAGE;
Adam Cohen1462de32012-07-24 22:34:36 -07002373 }
2374
Sunny Goyal527c7d32015-08-28 15:19:36 -07002375 @Override
2376 public void executeOnNextDraw(ViewOnDrawExecutor executor) {
Sunny Goyal6b6d0a32019-08-05 17:19:32 -07002377 clearPendingBinds();
Sunny Goyal527c7d32015-08-28 15:19:36 -07002378 mPendingExecutor = executor;
Sunny Goyal60180b02018-02-07 12:56:30 -08002379 if (!isInState(ALL_APPS)) {
vadimtd4c90e12019-06-04 13:59:43 -07002380 mAppsView.getAppsStore().enableDeferUpdates(AllAppsStore.DEFER_UPDATES_NEXT_DRAW);
2381 mPendingExecutor.execute(() -> mAppsView.getAppsStore().disableDeferUpdates(
2382 AllAppsStore.DEFER_UPDATES_NEXT_DRAW));
Sunny Goyal60180b02018-02-07 12:56:30 -08002383 }
2384
Sunny Goyal527c7d32015-08-28 15:19:36 -07002385 executor.attachTo(this);
2386 }
2387
2388 public void clearPendingExecutor(ViewOnDrawExecutor executor) {
2389 if (mPendingExecutor == executor) {
2390 mPendingExecutor = null;
2391 }
2392 }
2393
Sunny Goyalb5b9ad62016-04-02 11:23:39 -07002394 @Override
2395 public void finishFirstPageBind(final ViewOnDrawExecutor executor) {
Sunny Goyal6001ea22018-05-10 16:31:00 -07002396 AlphaProperty property = mDragLayer.getAlphaProperty(ALPHA_INDEX_LAUNCHER_LOAD);
2397 if (property.getValue() < 1) {
2398 ObjectAnimator anim = ObjectAnimator.ofFloat(property, MultiValueAlpha.VALUE, 1);
2399 if (executor != null) {
2400 anim.addListener(new AnimatorListenerAdapter() {
2401 @Override
2402 public void onAnimationEnd(Animator animation) {
2403 executor.onLoadAnimationCompleted();
2404 }
2405 });
2406 }
2407 anim.start();
Sunny Goyal29947f02017-12-18 13:49:44 -08002408 } else if (executor != null) {
2409 executor.onLoadAnimationCompleted();
Sunny Goyalb5b9ad62016-04-02 11:23:39 -07002410 }
2411 }
2412
Joe Onorato9c1289c2009-08-17 11:03:03 -04002413 /**
2414 * Callback saying that there aren't any more items to bind.
2415 *
2416 * Implementation of the method from LauncherModel.Callbacks.
2417 */
Tonyf80e8932018-12-21 11:58:04 -08002418 public void finishBindingItems(int pageBoundFirst) {
Winson Chung5cc62c72019-10-16 11:32:41 -07002419 Object traceToken = TraceHelper.INSTANCE.beginSection("finishBindingItems");
Adam Cohen1462de32012-07-24 22:34:36 -07002420 mWorkspace.restoreInstanceStateForRemainingPages();
Joe Onorato9c1289c2009-08-17 11:03:03 -04002421
Anjali Koppalff7ceff2014-05-01 18:26:37 -07002422 setWorkspaceLoading(false);
Adam Cohendb364c32014-05-20 14:23:40 -07002423
Sunny Goyal2100c782016-08-22 16:00:03 -07002424 if (mPendingActivityResult != null) {
2425 handleActivityResult(mPendingActivityResult.requestCode,
2426 mPendingActivityResult.resultCode, mPendingActivityResult.data);
2427 mPendingActivityResult = null;
Adam Cohendb364c32014-05-20 14:23:40 -07002428 }
2429
Sunny Goyala474a9b2017-05-04 16:47:11 -07002430 InstallShortcutReceiver.disableAndFlushInstallQueue(
2431 InstallShortcutReceiver.FLAG_LOADER_RUNNING, this);
Adam Cohen9211d422014-10-07 18:14:53 -07002432
Tonyf80e8932018-12-21 11:58:04 -08002433 // When undoing the removal of the last item on a page, return to that page.
Tony Wickham03f27012019-04-25 14:22:54 -07002434 // Since we are just resetting the current page without user interaction,
2435 // override the previous page so we don't log the page switch.
2436 mWorkspace.setCurrentPage(pageBoundFirst, pageBoundFirst /* overridePrevPage */);
Sunny Goyala7a5bf32020-01-05 15:35:29 +05302437 mPageToBindSynchronously = PagedView.INVALID_PAGE;
Tony Wickham6a71a5b2018-08-21 11:40:23 -07002438
Sunny Goyalac6f69f2019-08-16 11:59:55 -07002439 // Cache one page worth of icons
2440 getViewCache().setCacheSize(R.layout.folder_application,
2441 mDeviceProfile.inv.numFolderColumns * mDeviceProfile.inv.numFolderRows);
2442 getViewCache().setCacheSize(R.layout.folder_page, 2);
2443
Winson Chung5cc62c72019-10-16 11:32:41 -07002444 TraceHelper.INSTANCE.endSection(traceToken);
Winson Chungf0c6ae02012-03-21 16:10:31 -07002445 }
2446
Winson Chunga2413752012-04-03 14:22:34 -07002447 private boolean canRunNewAppsAnimation() {
2448 long diff = System.currentTimeMillis() - mDragController.getLastGestureUpTime();
Andrew Sapperstein932eb832016-06-30 18:10:09 -07002449 return diff > (NEW_APPS_ANIMATION_INACTIVE_TIMEOUT_SECONDS * 1000);
Winson Chunga2413752012-04-03 14:22:34 -07002450 }
2451
Winson Chungc9168342013-06-26 14:54:55 -07002452 private ValueAnimator createNewAppBounceAnimation(View v, int i) {
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002453 ValueAnimator bounceAnim = new PropertyListBuilder().alpha(1).scale(1).build(v)
2454 .setDuration(InstallShortcutReceiver.NEW_SHORTCUT_BOUNCE_DURATION);
Winson Chungc9168342013-06-26 14:54:55 -07002455 bounceAnim.setStartDelay(i * InstallShortcutReceiver.NEW_SHORTCUT_STAGGER_DELAY);
Sunny Goyal5a1f53b2015-05-27 10:24:24 -07002456 bounceAnim.setInterpolator(new OvershootInterpolator(BOUNCE_ANIMATION_TENSION));
Winson Chungc9168342013-06-26 14:54:55 -07002457 return bounceAnim;
2458 }
2459
Pinyao Tingc9074272019-11-11 11:51:44 -08002460 private void announceForAccessibility(@StringRes int stringResId) {
2461 getDragLayer().announceForAccessibility(getString(stringResId));
2462 }
2463
Amith Yamasani6d7fe502010-11-16 09:05:07 -08002464 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04002465 * Add the icons for all apps.
2466 *
2467 * Implementation of the method from LauncherModel.Callbacks.
2468 */
Sunny Goyal87dcde62019-07-17 20:35:56 -07002469 public void bindAllApplications(AppInfo[] apps) {
Sunny Goyal60180b02018-02-07 12:56:30 -08002470 mAppsView.getAppsStore().setApps(apps);
Joe Onorato9c1289c2009-08-17 11:03:03 -04002471 }
2472
2473 /**
Zak Cohen658c67a2018-10-19 14:21:05 -07002474 * Copies LauncherModel's map of activities to shortcut counts to Launcher's. This is necessary
Tony Wickhambfbf7f92016-05-19 11:19:39 -07002475 * because LauncherModel's map is updated in the background, while Launcher runs on the UI.
2476 */
2477 @Override
Zak Cohen658c67a2018-10-19 14:21:05 -07002478 public void bindDeepShortcutMap(HashMap<ComponentKey, Integer> deepShortcutMapCopy) {
Tony Wickham010d2552017-01-20 08:15:28 -08002479 mPopupDataProvider.setDeepShortcutMap(deepShortcutMapCopy);
Tony Wickham1bce7fd2016-04-28 17:39:03 -07002480 }
2481
Sunny Goyal4390ace2014-10-13 11:33:11 -07002482 @Override
Sunny Goyal29947f02017-12-18 13:49:44 -08002483 public void bindPromiseAppProgressUpdated(PromiseAppInfo app) {
Sunny Goyal60180b02018-02-07 12:56:30 -08002484 mAppsView.getAppsStore().updatePromiseAppProgress(app);
Mario Bertschler08ffaae2017-03-20 11:30:27 -07002485 }
2486
2487 @Override
Sunny Goyal29947f02017-12-18 13:49:44 -08002488 public void bindWidgetsRestored(ArrayList<LauncherAppWidgetInfo> widgets) {
Sunny Goyal4390ace2014-10-13 11:33:11 -07002489 mWorkspace.widgetsRestored(widgets);
2490 }
2491
Joe Onorato9c1289c2009-08-17 11:03:03 -04002492 /**
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07002493 * Some shortcuts were updated in the background.
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07002494 * Implementation of the method from LauncherModel.Callbacks.
Sunny Goyald3b87ef2016-07-28 12:11:54 -07002495 *
2496 * @param updated list of shortcuts which have changed.
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07002497 */
Sunny Goyal4390ace2014-10-13 11:33:11 -07002498 @Override
Sunny Goyal95899162019-03-27 16:03:06 -07002499 public void bindWorkspaceItemsChanged(ArrayList<WorkspaceItemInfo> updated) {
Sunny Goyal4390ace2014-10-13 11:33:11 -07002500 if (!updated.isEmpty()) {
2501 mWorkspace.updateShortcuts(updated);
2502 }
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07002503 }
2504
2505 /**
Chris Wrenaeff7ea2014-02-14 16:59:24 -05002506 * Update the state of a package, typically related to install state.
2507 *
2508 * Implementation of the method from LauncherModel.Callbacks.
2509 */
Sunny Goyale755d462014-07-22 13:48:29 -07002510 @Override
Sunny Goyal29947f02017-12-18 13:49:44 -08002511 public void bindRestoreItemsChange(HashSet<ItemInfo> updates) {
Sunny Goyal756adbc2015-04-16 15:20:51 -07002512 mWorkspace.updateRestoreItems(updates);
Sunny Goyala22666f2014-09-18 13:25:15 -07002513 }
2514
2515 /**
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07002516 * A package was uninstalled/updated. We take both the super set of packageNames
Winson Chung83892cc2013-05-01 16:53:33 -07002517 * in addition to specific applications to remove, the reason being that
2518 * this can be called when a package is updated as well. In that scenario,
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07002519 * we only remove specific components from the workspace and hotseat, where as
Winson Chung83892cc2013-05-01 16:53:33 -07002520 * package-removal should clear all items by package name.
Joe Onorato9c1289c2009-08-17 11:03:03 -04002521 */
Sunny Goyal1a745e82014-10-02 15:58:31 -07002522 @Override
Sunny Goyal6e13dd32017-08-17 03:01:19 -07002523 public void bindWorkspaceComponentsRemoved(final ItemInfoMatcher matcher) {
Sunny Goyal6e13dd32017-08-17 03:01:19 -07002524 mWorkspace.removeItemsByMatcher(matcher);
2525 mDragController.onAppsRemoved(matcher);
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07002526 }
Sunny Goyal4390ace2014-10-13 11:33:11 -07002527
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07002528 @Override
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07002529 public void bindAllWidgets(final ArrayList<WidgetListRowEntry> allWidgets) {
2530 mPopupDataProvider.setAllWidgets(allWidgets);
Tony Wickham26b17462017-03-20 17:12:24 -07002531 }
2532
Tony Wickham86222d22017-03-29 15:30:43 -07002533 /**
2534 * @param packageUser if null, refreshes all widgets and shortcuts, otherwise only
2535 * refreshes the widgets and shortcuts associated with the given package/user
2536 */
2537 public void refreshAndBindWidgetsForPackageUser(@Nullable PackageUserKey packageUser) {
Sunny Goyalc6e97692017-06-02 13:46:55 -07002538 mModel.refreshAndBindWidgetsAndShortcuts(packageUser);
Sunny Goyal2e1efb42016-03-03 16:58:55 -08002539 }
2540
Winson Chung80baf5a2010-08-09 16:03:15 -07002541 /**
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08002542 * $ adb shell dumpsys activity com.android.launcher3.Launcher [--all]
Joe Onoratobe386092009-11-17 17:32:16 -08002543 */
Adam Cohen16d7ffc2011-10-05 17:49:14 -07002544 @Override
2545 public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) {
2546 super.dump(prefix, fd, writer, args);
Sunny Goyala1365452015-10-01 15:46:24 -07002547
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08002548 if (args.length > 0 && TextUtils.equals(args[0], "--all")) {
2549 writer.println(prefix + "Workspace Items");
Sunny Goyal7ce471b2017-08-02 03:37:39 -07002550 for (int i = 0; i < mWorkspace.getPageCount(); i++) {
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08002551 writer.println(prefix + " Homescreen " + i);
2552
2553 ViewGroup layout = ((CellLayout) mWorkspace.getPageAt(i)).getShortcutsAndWidgets();
2554 for (int j = 0; j < layout.getChildCount(); j++) {
2555 Object tag = layout.getChildAt(j).getTag();
2556 if (tag != null) {
2557 writer.println(prefix + " " + tag.toString());
2558 }
2559 }
2560 }
2561
2562 writer.println(prefix + " Hotseat");
Sunny Goyal876e4622018-11-02 13:50:40 -07002563 ViewGroup layout = mHotseat.getShortcutsAndWidgets();
Sunny Goyala1365452015-10-01 15:46:24 -07002564 for (int j = 0; j < layout.getChildCount(); j++) {
2565 Object tag = layout.getChildAt(j).getTag();
2566 if (tag != null) {
2567 writer.println(prefix + " " + tag.toString());
2568 }
Adam Cohen4caf2982013-08-20 18:54:31 -07002569 }
Sunny Goyala1365452015-10-01 15:46:24 -07002570 }
2571
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08002572 writer.println(prefix + "Misc:");
Winson Chungef528762019-09-06 12:05:52 -07002573 dumpMisc(prefix + "\t", writer);
2574 writer.println(prefix + "\tmWorkspaceLoading=" + mWorkspaceLoading);
2575 writer.println(prefix + "\tmPendingRequestArgs=" + mPendingRequestArgs
2576 + " mPendingActivityResult=" + mPendingActivityResult);
2577 writer.println(prefix + "\tmRotationHelper: " + mRotationHelper);
2578 writer.println(prefix + "\tmAppWidgetHost.isListening: " + mAppWidgetHost.isListening());
2579
Sunny Goyalcb2c5052018-10-15 12:30:29 -07002580 // Extra logging for b/116853349
Hyunyoung Songa310a802019-04-25 13:57:16 -07002581 mDragLayer.dump(prefix, writer);
2582 mStateManager.dump(prefix, writer);
Sunny Goyal2bba1902018-02-27 12:20:50 -08002583
2584 try {
2585 FileLog.flushAll(writer);
2586 } catch (Exception e) {
2587 // Ignore
2588 }
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08002589
2590 mModel.dumpState(prefix, fd, writer, args);
Sunny Goyala1365452015-10-01 15:46:24 -07002591
Adam Cohen9211d422014-10-07 18:14:53 -07002592 if (mLauncherCallbacks != null) {
2593 mLauncherCallbacks.dump(prefix, fd, writer, args);
2594 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -07002595 mOverlayManager.dump(prefix, writer);
Adam Cohen16d7ffc2011-10-05 17:49:14 -07002596 }
Adam Cohen487f7dd2012-06-28 18:12:10 -07002597
Sunny Goyal66b24572016-09-21 15:57:55 -07002598 @Override
Sunny Goyal66b24572016-09-21 15:57:55 -07002599 public void onProvideKeyboardShortcuts(
2600 List<KeyboardShortcutGroup> data, Menu menu, int deviceId) {
2601
2602 ArrayList<KeyboardShortcutInfo> shortcutInfos = new ArrayList<>();
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07002603 if (isInState(NORMAL)) {
Sunny Goyal66b24572016-09-21 15:57:55 -07002604 shortcutInfos.add(new KeyboardShortcutInfo(getString(R.string.all_apps_button_label),
2605 KeyEvent.KEYCODE_A, KeyEvent.META_CTRL_ON));
Vadim Tryshev74c261c2018-06-12 13:44:43 -07002606 shortcutInfos.add(new KeyboardShortcutInfo(getString(R.string.widget_button_text),
2607 KeyEvent.KEYCODE_W, KeyEvent.META_CTRL_ON));
Sunny Goyal66b24572016-09-21 15:57:55 -07002608 }
Vadim Tryshev3455f8d2018-05-11 20:02:20 -07002609 final View currentFocus = getCurrentFocus();
2610 if (currentFocus != null) {
2611 if (new CustomActionsPopup(this, currentFocus).canShow()) {
2612 shortcutInfos.add(new KeyboardShortcutInfo(getString(R.string.custom_actions),
2613 KeyEvent.KEYCODE_O, KeyEvent.META_CTRL_ON));
2614 }
2615 if (currentFocus.getTag() instanceof ItemInfo
Pinyao Ting49a3e692019-07-26 12:28:38 -07002616 && ShortcutUtil.supportsShortcuts((ItemInfo) currentFocus.getTag())) {
Vadim Tryshev3455f8d2018-05-11 20:02:20 -07002617 shortcutInfos.add(new KeyboardShortcutInfo(
2618 getString(R.string.shortcuts_menu_with_notifications_description),
2619 KeyEvent.KEYCODE_S, KeyEvent.META_CTRL_ON));
2620 }
Sunny Goyal66b24572016-09-21 15:57:55 -07002621 }
2622 if (!shortcutInfos.isEmpty()) {
2623 data.add(new KeyboardShortcutGroup(getString(R.string.home_screen), shortcutInfos));
2624 }
2625
2626 super.onProvideKeyboardShortcuts(data, menu, deviceId);
2627 }
2628
2629 @Override
2630 public boolean onKeyShortcut(int keyCode, KeyEvent event) {
2631 if (event.hasModifiers(KeyEvent.META_CTRL_ON)) {
2632 switch (keyCode) {
2633 case KeyEvent.KEYCODE_A:
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07002634 if (isInState(NORMAL)) {
2635 getStateManager().goToState(ALL_APPS);
Sunny Goyal66b24572016-09-21 15:57:55 -07002636 return true;
2637 }
2638 break;
2639 case KeyEvent.KEYCODE_S: {
2640 View focusedView = getCurrentFocus();
2641 if (focusedView instanceof BubbleTextView
2642 && focusedView.getTag() instanceof ItemInfo
2643 && mAccessibilityDelegate.performAction(focusedView,
Samuel Fufaca37b8a2019-08-19 17:04:36 -07002644 (ItemInfo) focusedView.getTag(),
2645 LauncherAccessibilityDelegate.DEEP_SHORTCUTS)) {
Sunny Goyal00ac9202017-11-09 15:24:06 -08002646 PopupContainerWithArrow.getOpen(this).requestFocus();
Sunny Goyal66b24572016-09-21 15:57:55 -07002647 return true;
2648 }
2649 break;
2650 }
2651 case KeyEvent.KEYCODE_O:
2652 if (new CustomActionsPopup(this, getCurrentFocus()).show()) {
2653 return true;
2654 }
2655 break;
Vadim Tryshev74c261c2018-06-12 13:44:43 -07002656 case KeyEvent.KEYCODE_W:
2657 if (isInState(NORMAL)) {
2658 OptionsPopupView.openWidgets(this);
2659 return true;
2660 }
2661 break;
Sunny Goyal66b24572016-09-21 15:57:55 -07002662 }
2663 }
2664 return super.onKeyShortcut(keyCode, event);
2665 }
2666
Vadim Tryshev646a0dd2018-02-05 16:27:50 -08002667 @Override
2668 public boolean onKeyUp(int keyCode, KeyEvent event) {
2669 if (keyCode == KeyEvent.KEYCODE_MENU) {
2670 // KEYCODE_MENU is sent by some tests, for example
2671 // LauncherJankTests#testWidgetsContainerFling. Don't just remove its handling.
2672 if (!mDragController.isDragging() && !mWorkspace.isSwitchingState() &&
2673 isInState(NORMAL)) {
2674 // Close any open floating views.
2675 AbstractFloatingView.closeAllOpenViews(this);
2676
2677 // Setting the touch point to (-1, -1) will show the options popup in the center of
2678 // the screen.
vadimtbc5d7e62019-12-09 13:53:05 -08002679 if (Utilities.IS_RUNNING_IN_TEST_HARNESS) {
2680 Log.d(TestProtocol.PERMANENT_DIAG_TAG, "Opening options popup on key up");
2681 }
Sunny Goyal2fd7a8b2018-03-30 17:10:13 -07002682 OptionsPopupView.showDefaultOptions(this, -1, -1);
Vadim Tryshev646a0dd2018-02-05 16:27:50 -08002683 }
2684 return true;
2685 }
2686 return super.onKeyUp(keyCode, event);
2687 }
2688
Sunny Goyal210e1742019-10-17 12:05:38 -07002689 protected StateHandler[] createStateHandlers() {
2690 return new StateHandler[] { getAllAppsController(), getWorkspace() };
Andrew Sappersteinabef55a2016-06-19 12:49:00 -07002691 }
2692
Sunny Goyal210e1742019-10-17 12:05:38 -07002693 public TouchController[] createTouchControllers() {
2694 return new TouchController[] {getDragController(), new AllAppsSwipeController(this)};
2695 }
2696
2697 protected RotationMode getFakeRotationMode(DeviceProfile deviceProfile) {
2698 return RotationMode.NORMAL;
2699 }
2700
2701 protected ScaleAndTranslation getOverviewScaleAndTranslationForNormalState() {
2702 return new ScaleAndTranslation(1.1f, 0f, 0f);
2703 }
2704
2705 public void useFadeOutAnimationForLauncherStart(CancellationSignal signal) { }
2706
2707 public void onDragLayerHierarchyChanged() { }
2708
Vinit Nayakf9b585b2019-07-10 14:25:32 -07002709 @Override
2710 public void returnToHomescreen() {
2711 super.returnToHomescreen();
2712 getStateManager().goToState(LauncherState.NORMAL);
2713 }
2714
Sunny Goyal3a1eadd2019-10-23 17:44:27 -07002715 public Stream<SystemShortcut.Factory> getSupportedShortcuts() {
Samuel Fufa5cf3e862020-02-03 20:22:54 -08002716 return Stream.of(APP_INFO, WIDGETS, INSTALL);
Sunny Goyal3a1eadd2019-10-23 17:44:27 -07002717 }
2718
Sunny Goyal210e1742019-10-17 12:05:38 -07002719 public static Launcher getLauncher(Context context) {
2720 return (Launcher) fromContext(context);
2721 }
2722
Sunny Goyal3dce5f32017-10-05 11:40:05 -07002723 /**
Sunny Goyalab770a12018-11-14 15:17:26 -08002724 * Just a wrapper around the type cast to allow easier tracking of calls.
2725 */
2726 public static <T extends Launcher> T cast(ActivityContext activityContext) {
2727 return (T) activityContext;
2728 }
2729
2730 /**
Sunny Goyal3dce5f32017-10-05 11:40:05 -07002731 * Callback for listening for onResume
2732 */
2733 public interface OnResumeCallback {
2734
2735 void onLauncherResume();
2736 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002737}