blob: 1546ee35726d7ab6ca9d2ddf68c6eaf3441fa745 [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;
Sunny Goyal6c0c61a2020-12-08 19:19:56 -080021import static android.content.pm.ActivityInfo.CONFIG_UI_MODE;
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -070022import static android.view.View.IMPORTANT_FOR_ACCESSIBILITY_NO;
Sunny Goyal8f965462020-04-23 19:00:36 -070023import static android.view.accessibility.AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED;
Vinit Nayak48b28022020-04-27 20:48:49 +000024
Pinyao Tinga74b63a2019-07-17 23:26:06 -070025import static com.android.launcher3.AbstractFloatingView.TYPE_ALL;
Sunny Goyal30ac97d2020-06-24 23:47:46 -070026import static com.android.launcher3.AbstractFloatingView.TYPE_ICON_SURFACE;
Pinyao Tinga74b63a2019-07-17 23:26:06 -070027import static com.android.launcher3.AbstractFloatingView.TYPE_REBIND_SAFE;
Tony Wickham6a71a5b2018-08-21 11:40:23 -070028import static com.android.launcher3.AbstractFloatingView.TYPE_SNACKBAR;
Sunny Goyal4c7f2152017-10-17 17:17:16 -070029import static com.android.launcher3.LauncherAnimUtils.SPRING_LOADED_EXIT_DELAY;
Sunny Goyal3e3f44c2017-10-23 17:14:52 -070030import static com.android.launcher3.LauncherState.ALL_APPS;
Sunny Goyal8f965462020-04-23 19:00:36 -070031import static com.android.launcher3.LauncherState.FLAG_CLOSE_POPUPS;
32import static com.android.launcher3.LauncherState.FLAG_MULTI_PAGE;
33import static com.android.launcher3.LauncherState.FLAG_NON_INTERACTIVE;
Sunny Goyal3e3f44c2017-10-23 17:14:52 -070034import static com.android.launcher3.LauncherState.NORMAL;
Sunny Goyalf2393f12020-04-01 20:13:12 -070035import static com.android.launcher3.LauncherState.NO_OFFSET;
36import static com.android.launcher3.LauncherState.NO_SCALE;
Govinda Wassermanc06e1512019-04-09 09:56:53 -040037import static com.android.launcher3.LauncherState.OVERVIEW;
Sunny Goyal8f965462020-04-23 19:00:36 -070038import static com.android.launcher3.LauncherState.SPRING_LOADED;
Sunny Goyalb1d7de22019-09-06 10:36:54 -070039import static com.android.launcher3.Utilities.postAsyncCallback;
Sunny Goyal384b5782021-02-09 22:50:02 -080040import static com.android.launcher3.accessibility.LauncherAccessibilityDelegate.getSupportedActions;
Sunny Goyal6001ea22018-05-10 16:31:00 -070041import static com.android.launcher3.dragndrop.DragLayer.ALPHA_INDEX_LAUNCHER_LOAD;
Hyunyoung Song801f81f2020-06-19 02:58:53 -070042import static com.android.launcher3.logging.StatsLogManager.LAUNCHER_STATE_BACKGROUND;
Hyunyoung Song95786e02020-09-15 00:34:10 -070043import static com.android.launcher3.logging.StatsLogManager.LAUNCHER_STATE_HOME;
thiruramc96873c2021-02-11 15:13:47 -080044import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ALLAPPS_ENTRY;
thiruram9f53d612021-02-24 10:54:01 -080045import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ALLAPPS_ENTRY_WITH_DEVICE_SEARCH;
thiruramc96873c2021-02-11 15:13:47 -080046import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ALLAPPS_EXIT;
Hyunyoung Song801f81f2020-06-19 02:58:53 -070047import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ONRESUME;
48import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ONSTOP;
Sunny Goyal60e68c92020-08-12 13:59:27 -070049import static com.android.launcher3.model.ItemInstallQueue.FLAG_ACTIVITY_PAUSED;
50import static com.android.launcher3.model.ItemInstallQueue.FLAG_DRAG_AND_DROP;
51import static com.android.launcher3.model.ItemInstallQueue.FLAG_LOADER_RUNNING;
Sunny Goyal3a1eadd2019-10-23 17:44:27 -070052import static com.android.launcher3.popup.SystemShortcut.APP_INFO;
Sunny Goyal3a1eadd2019-10-23 17:44:27 -070053import static com.android.launcher3.popup.SystemShortcut.INSTALL;
54import static com.android.launcher3.popup.SystemShortcut.WIDGETS;
Sunny Goyal8f965462020-04-23 19:00:36 -070055import static com.android.launcher3.states.RotationHelper.REQUEST_LOCK;
Sunny Goyalbe8c3402019-05-22 15:17:52 -070056import static com.android.launcher3.states.RotationHelper.REQUEST_NONE;
Sunny Goyal326403e2017-10-02 12:45:10 -070057
Gilles Debunnedd6c9922010-10-25 11:23:41 -070058import android.animation.Animator;
Sunny Goyal6001ea22018-05-10 16:31:00 -070059import android.animation.AnimatorListenerAdapter;
Gilles Debunnedd6c9922010-10-25 11:23:41 -070060import android.animation.AnimatorSet;
Sunny Goyal6001ea22018-05-10 16:31:00 -070061import android.animation.ObjectAnimator;
Gilles Debunnedd6c9922010-10-25 11:23:41 -070062import android.animation.ValueAnimator;
Adam Cohen0b395352014-06-09 22:54:36 +000063import android.annotation.TargetApi;
Adam Cohen0cf2a7c2011-11-08 15:07:01 -080064import android.appwidget.AppWidgetHostView;
Michael Jurkaaf442092010-06-10 17:01:57 -070065import android.appwidget.AppWidgetManager;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080066import android.content.ActivityNotFoundException;
Joe Onorato2ca0ae72009-11-10 13:14:13 -080067import android.content.BroadcastReceiver;
Michael Jurkae326f182011-11-21 14:05:46 -080068import android.content.ComponentCallbacks2;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080069import android.content.Context;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080070import android.content.Intent;
Winson Chungf0ea4d32011-06-06 14:27:16 -070071import android.content.IntentFilter;
Adam Cohen173f7112015-03-27 15:14:00 -070072import android.content.IntentSender;
Winson Chung82f55532011-08-09 14:14:23 -070073import android.content.SharedPreferences;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080074import android.content.pm.PackageManager;
Sunny Goyalf8d56fc2018-01-31 15:18:11 -080075import android.content.res.Configuration;
Adam Cohen3f9c9712014-10-31 11:48:25 -070076import android.database.sqlite.SQLiteDatabase;
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -070077import android.graphics.Bitmap;
Tony Wickham1906cc32021-02-11 11:55:24 -080078import android.graphics.Rect;
Adam Cohen0f668f32014-09-08 19:54:17 +020079import android.os.Build;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080080import android.os.Bundle;
Sunny Goyal210e1742019-10-17 12:05:38 -070081import android.os.CancellationSignal;
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -070082import android.os.Parcelable;
Sunny Goyal7c74e4a2016-12-15 15:53:17 -080083import android.os.Process;
Winson Chunga2413752012-04-03 14:22:34 -070084import android.os.StrictMode;
Riddle Hsu979da642020-09-22 21:52:40 +080085import android.os.SystemClock;
Michael Jurkaa33411c2012-06-14 16:18:21 -070086import android.text.TextUtils;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080087import android.text.method.TextKeyListener;
Joe Onorato7c312c12009-08-13 21:36:53 -070088import android.util.Log;
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -070089import android.util.SparseArray;
Adam Cohen96d30a12013-07-16 18:13:21 -070090import android.view.KeyEvent;
Sunny Goyal66b24572016-09-21 15:57:55 -070091import android.view.KeyboardShortcutGroup;
92import android.view.KeyboardShortcutInfo;
Sunny Goyal9b29ca52017-02-17 10:39:44 -080093import android.view.LayoutInflater;
Adam Cohen96d30a12013-07-16 18:13:21 -070094import android.view.Menu;
vadimt9af34a72020-01-21 11:19:13 -080095import android.view.MotionEvent;
Adam Cohen96d30a12013-07-16 18:13:21 -070096import android.view.View;
Adam Cohen96d30a12013-07-16 18:13:21 -070097import android.view.ViewGroup;
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -070098import android.view.WindowManager.LayoutParams;
Svetoslav Ganov815ba2d2011-01-07 14:55:17 -080099import android.view.accessibility.AccessibilityEvent;
Sunny Goyal5a1f53b2015-05-27 10:24:24 -0700100import android.view.animation.OvershootInterpolator;
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -0700101import android.widget.ImageView;
Adam Cohen96d30a12013-07-16 18:13:21 -0700102import android.widget.Toast;
Sunny Goyala1d1bf32015-06-26 13:24:53 -0700103
Sunny Goyal35e7d382020-05-08 13:37:58 -0700104import androidx.annotation.CallSuper;
Sunny Goyal11a50742019-08-07 09:24:26 -0700105import androidx.annotation.Nullable;
Pinyao Tingc9074272019-11-11 11:51:44 -0800106import androidx.annotation.StringRes;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700107import androidx.annotation.VisibleForTesting;
Sunny Goyal11a50742019-08-07 09:24:26 -0700108
Sunny Goyal651077b2014-06-30 14:15:31 -0700109import com.android.launcher3.DropTarget.DragObject;
Sunny Goyalae502842016-06-17 08:43:56 -0700110import com.android.launcher3.accessibility.LauncherAccessibilityDelegate;
Sunny Goyal384b5782021-02-09 22:50:02 -0800111import com.android.launcher3.accessibility.LauncherAccessibilityDelegate.LauncherAction;
Winson Chung5f4e0fd2015-05-22 11:12:27 -0700112import com.android.launcher3.allapps.AllAppsContainerView;
vadimtd4c90e12019-06-04 13:59:43 -0700113import com.android.launcher3.allapps.AllAppsStore;
Hyunyoung Song645764e2016-06-06 14:19:02 -0700114import com.android.launcher3.allapps.AllAppsTransitionController;
Sunny Goyal7ede6112017-12-05 15:11:21 -0800115import com.android.launcher3.allapps.DiscoveryBounce;
Samuel Fufa37432442020-11-01 13:06:43 -0800116import com.android.launcher3.allapps.search.LiveSearchManager;
Sunny Goyalf0b6db72018-08-13 16:10:14 -0700117import com.android.launcher3.anim.PropertyListBuilder;
Sunny Goyal8f965462020-04-23 19:00:36 -0700118import com.android.launcher3.compat.AccessibilityManagerCompat;
Tony Wickhame0c33232016-02-08 11:37:04 -0800119import com.android.launcher3.config.FeatureFlags;
vadimt00d42552018-12-11 17:59:36 -0800120import com.android.launcher3.dot.DotInfo;
Vadim Tryshevfedca432015-08-19 17:55:02 -0700121import com.android.launcher3.dragndrop.DragController;
122import com.android.launcher3.dragndrop.DragLayer;
Tony Wickham39938cb2021-02-26 09:15:31 -0800123import com.android.launcher3.dragndrop.DragOptions;
Vadim Tryshevfedca432015-08-19 17:55:02 -0700124import com.android.launcher3.dragndrop.DragView;
Sunny Goyal11a50742019-08-07 09:24:26 -0700125import com.android.launcher3.folder.FolderGridOrganizer;
Sunny Goyal26119432016-02-18 22:09:23 +0000126import com.android.launcher3.folder.FolderIcon;
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -0700127import com.android.launcher3.icons.BitmapRenderer;
Sunny Goyalf840f102018-09-21 14:41:05 -0700128import com.android.launcher3.icons.IconCache;
Sunny Goyal3333b0c2016-05-09 20:43:21 -0700129import com.android.launcher3.keyboard.ViewGroupFocusHelper;
Hyunyoung Song801f81f2020-06-19 02:58:53 -0700130import com.android.launcher3.logger.LauncherAtom;
Sunny Goyala7ce1662016-05-31 15:01:35 -0700131import com.android.launcher3.logging.FileLog;
thiruramc96873c2021-02-11 15:13:47 -0800132import com.android.launcher3.logging.InstanceId;
133import com.android.launcher3.logging.InstanceIdSequence;
Hyunyoung Song801f81f2020-06-19 02:58:53 -0700134import com.android.launcher3.logging.StatsLogManager;
Sunny Goyal87dcde62019-07-17 20:35:56 -0700135import com.android.launcher3.model.BgDataModel.Callbacks;
Sunny Goyal60e68c92020-08-12 13:59:27 -0700136import com.android.launcher3.model.ItemInstallQueue;
Sunny Goyal53116c62020-08-07 16:32:18 -0700137import com.android.launcher3.model.ModelUtils;
Sunny Goyala535ae42017-02-27 10:07:13 -0800138import com.android.launcher3.model.ModelWriter;
Sunny Goyale396abf2020-04-06 15:11:17 -0700139import com.android.launcher3.model.data.AppInfo;
140import com.android.launcher3.model.data.FolderInfo;
141import com.android.launcher3.model.data.ItemInfo;
142import com.android.launcher3.model.data.LauncherAppWidgetInfo;
Sunny Goyale396abf2020-04-06 15:11:17 -0700143import com.android.launcher3.model.data.WorkspaceItemInfo;
Sunny Goyala535ae42017-02-27 10:07:13 -0800144import com.android.launcher3.notification.NotificationListener;
Sunny Goyale7b00122019-10-02 16:13:34 -0700145import com.android.launcher3.pm.PinRequestHelper;
Samuel Fufa41d909f2020-03-20 16:27:09 -0700146import com.android.launcher3.pm.UserCache;
Tony Wickham540913e2017-01-23 11:47:51 -0800147import com.android.launcher3.popup.PopupContainerWithArrow;
Sunny Goyala535ae42017-02-27 10:07:13 -0800148import com.android.launcher3.popup.PopupDataProvider;
Sunny Goyal3a1eadd2019-10-23 17:44:27 -0700149import com.android.launcher3.popup.SystemShortcut;
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700150import com.android.launcher3.qsb.QsbContainerView;
Sunny Goyal35e7d382020-05-08 13:37:58 -0700151import com.android.launcher3.statemanager.StateManager;
152import com.android.launcher3.statemanager.StateManager.StateHandler;
153import com.android.launcher3.statemanager.StateManager.StateListener;
154import com.android.launcher3.statemanager.StatefulActivity;
Sunny Goyal623eddd2018-03-02 12:24:41 -0800155import com.android.launcher3.states.RotationHelper;
vadimt9af34a72020-01-21 11:19:13 -0800156import com.android.launcher3.testing.TestLogging;
vadimtbc5d7e62019-12-09 13:53:05 -0800157import com.android.launcher3.testing.TestProtocol;
Sunny Goyal210e1742019-10-17 12:05:38 -0700158import com.android.launcher3.touch.AllAppsSwipeController;
Sunny Goyal8a2a63b2018-03-06 22:15:18 -0800159import com.android.launcher3.touch.ItemClickHandler;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700160import com.android.launcher3.uioverrides.plugins.PluginManagerWrapper;
Sunny Goyal2100c782016-08-22 16:00:03 -0700161import com.android.launcher3.util.ActivityResultInfo;
Sunny Goyale84c5b82019-09-26 17:05:31 -0700162import com.android.launcher3.util.ActivityTracker;
Winson Chung6b1c73f2015-06-18 11:38:42 -0700163import com.android.launcher3.util.ComponentKey;
Sunny Goyalefb7e842018-10-04 15:11:00 -0700164import com.android.launcher3.util.IntArray;
Sunny Goyald3b87ef2016-07-28 12:11:54 -0700165import com.android.launcher3.util.ItemInfoMatcher;
Sunny Goyal6001ea22018-05-10 16:31:00 -0700166import com.android.launcher3.util.MultiValueAlpha;
167import com.android.launcher3.util.MultiValueAlpha.AlphaProperty;
Tony Wickham133cd542020-04-08 17:48:41 -0700168import com.android.launcher3.util.OnboardingPrefs;
Sunny Goyal04cc3a72016-05-17 10:32:43 -0700169import com.android.launcher3.util.PackageManagerHelper;
Tony Wickham010d2552017-01-20 08:15:28 -0800170import com.android.launcher3.util.PackageUserKey;
Sunny Goyal2100c782016-08-22 16:00:03 -0700171import com.android.launcher3.util.PendingRequestArgs;
Samuel Fufa41d909f2020-03-20 16:27:09 -0700172import com.android.launcher3.util.SafeCloseable;
Sunny Goyal8392c822017-06-20 10:03:56 -0700173import com.android.launcher3.util.SystemUiController;
Mario Bertschlera6936942017-05-31 14:48:19 -0700174import com.android.launcher3.util.Themes;
Adam Cohen091440a2015-03-18 14:16:05 -0700175import com.android.launcher3.util.Thunk;
Sunny Goyal210e1742019-10-17 12:05:38 -0700176import com.android.launcher3.util.TouchController;
Sunny Goyalfca6bc92017-09-28 16:28:34 -0700177import com.android.launcher3.util.TraceHelper;
Sunny Goyal326403e2017-10-02 12:45:10 -0700178import com.android.launcher3.util.UiThreadHelper;
Sunny Goyal527c7d32015-08-28 15:19:36 -0700179import com.android.launcher3.util.ViewOnDrawExecutor;
Sunny Goyalab770a12018-11-14 15:17:26 -0800180import com.android.launcher3.views.ActivityContext;
Sunny Goyal30ac97d2020-06-24 23:47:46 -0700181import com.android.launcher3.views.FloatingSurfaceView;
Sunny Goyal7c7be8c2018-03-07 19:58:07 -0800182import com.android.launcher3.views.OptionsPopupView;
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400183import com.android.launcher3.views.ScrimView;
Yogisha Dixit741fae92021-02-22 14:03:44 +0000184import com.android.launcher3.widget.LauncherAppWidgetHost;
Sunny Goyal29947f02017-12-18 13:49:44 -0800185import com.android.launcher3.widget.LauncherAppWidgetHostView;
Yogisha Dixit741fae92021-02-22 14:03:44 +0000186import com.android.launcher3.widget.LauncherAppWidgetProviderInfo;
Sunny Goyal782f0c92017-01-19 10:27:54 -0800187import com.android.launcher3.widget.PendingAddShortcutInfo;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700188import com.android.launcher3.widget.PendingAddWidgetInfo;
Sunny Goyal29947f02017-12-18 13:49:44 -0800189import com.android.launcher3.widget.PendingAppWidgetHostView;
Sunny Goyal04a324a2017-01-20 21:08:59 -0800190import com.android.launcher3.widget.WidgetAddFlowHandler;
Hyunyoung Songb99ff3e2015-04-23 15:17:50 -0700191import com.android.launcher3.widget.WidgetHostViewLoader;
Sunny Goyal337c81f2019-12-10 12:19:13 -0800192import com.android.launcher3.widget.WidgetManagerHelper;
Pinyao Tingc7a6c292019-08-26 14:36:02 -0700193import com.android.launcher3.widget.custom.CustomWidgetManager;
Steven Ng2f5648a2021-02-08 17:18:25 +0000194import com.android.launcher3.widget.model.WidgetsListBaseEntry;
195import com.android.launcher3.widget.picker.WidgetsFullSheet;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700196import com.android.systemui.plugins.OverlayPlugin;
197import com.android.systemui.plugins.PluginListener;
198import com.android.systemui.plugins.shared.LauncherExterns;
199import com.android.systemui.plugins.shared.LauncherOverlayManager;
200import com.android.systemui.plugins.shared.LauncherOverlayManager.LauncherOverlay;
201import com.android.systemui.plugins.shared.LauncherOverlayManager.LauncherOverlayCallbacks;
Adam Cohen6c5891a2014-07-09 23:53:15 -0700202
Adam Cohen16d7ffc2011-10-05 17:49:14 -0700203import java.io.FileDescriptor;
Adam Cohen16d7ffc2011-10-05 17:49:14 -0700204import java.io.PrintWriter;
Adam Cohenc0dcf592011-06-01 15:30:43 -0700205import java.util.ArrayList;
Winson Chungf0c6ae02012-03-21 16:10:31 -0700206import java.util.Collection;
Zak Cohen658c67a2018-10-19 14:21:05 -0700207import java.util.HashMap;
Sunny Goyal4390ace2014-10-13 11:33:11 -0700208import java.util.HashSet;
Michael Jurkad7c28052012-04-27 15:43:36 -0700209import java.util.List;
Sunny Goyalaae6fbb2019-01-31 16:05:58 -0800210import java.util.function.Predicate;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700211import java.util.function.Supplier;
Sunny Goyal3a1eadd2019-10-23 17:44:27 -0700212import java.util.stream.Stream;
Jon Mirandaf5197fc2019-09-04 16:55:41 -0700213
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800214/**
215 * Default launcher application.
216 */
Sunny Goyal35e7d382020-05-08 13:37:58 -0700217public class Launcher extends StatefulActivity<LauncherState> implements LauncherExterns,
Sunny Goyal79e52fc2021-02-03 10:22:28 -0800218 Callbacks, InvariantDeviceProfile.OnIDPChangeListener, PluginListener<OverlayPlugin> {
Vadim Tryshevfedca432015-08-19 17:55:02 -0700219 public static final String TAG = "Launcher";
Sunny Goyale84c5b82019-09-26 17:05:31 -0700220
221 public static final ActivityTracker<Launcher> ACTIVITY_TRACKER = new ActivityTracker<>();
222
Sunny Goyal2bba4c32015-05-18 15:42:48 -0700223 static final boolean LOGD = false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800224
Winson Chunga2413752012-04-03 14:22:34 -0700225 static final boolean DEBUG_STRICT_MODE = false;
Romain Guy6fefcf12009-06-11 13:07:43 -0700226
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800227 private static final int REQUEST_CREATE_SHORTCUT = 1;
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700228 private static final int REQUEST_CREATE_APPWIDGET = 5;
Jon Mirandac476d6e2017-05-04 16:30:01 -0700229
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700230 private static final int REQUEST_PICK_APPWIDGET = 9;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800231
Michael Jurka8b805b12012-04-18 14:23:14 -0700232 private static final int REQUEST_BIND_APPWIDGET = 11;
Sunny Goyal8a2a63b2018-03-06 22:15:18 -0800233 public static final int REQUEST_BIND_PENDING_APPWIDGET = 12;
234 public static final int REQUEST_RECONFIGURE_APPWIDGET = 13;
Michael Jurka8b805b12012-04-18 14:23:14 -0700235
Jon Mirandac476d6e2017-05-04 16:30:01 -0700236 private static final int REQUEST_PERMISSION_CALL_PHONE = 14;
Sunny Goyal28c6b962015-10-12 11:42:05 -0700237
Sunny Goyal5a1f53b2015-05-27 10:24:24 -0700238 private static final float BOUNCE_ANIMATION_TENSION = 1.3f;
239
Mathew Inwood876a8462013-06-14 14:12:41 +0100240 /**
241 * IntentStarter uses request codes starting with this. This must be greater than all activity
242 * request codes used internally.
243 */
244 protected static final int REQUEST_LAST = 100;
245
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800246 // Type: int
247 private static final String RUNTIME_STATE_CURRENT_SCREEN = "launcher.current_screen";
Michael Jurka883f55b2010-10-21 15:47:14 -0700248 // Type: int
249 private static final String RUNTIME_STATE = "launcher.state";
Sunny Goyal2100c782016-08-22 16:00:03 -0700250 // Type: PendingRequestArgs
251 private static final String RUNTIME_STATE_PENDING_REQUEST_ARGS = "launcher.request_args";
Sunny Goyaldedda052019-05-14 15:23:48 -0700252 // Type: int
253 private static final String RUNTIME_STATE_PENDING_REQUEST_CODE = "launcher.request_code";
Sunny Goyal2100c782016-08-22 16:00:03 -0700254 // Type: ActivityResultInfo
255 private static final String RUNTIME_STATE_PENDING_ACTIVITY_RESULT = "launcher.activity_result";
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -0700256 // Type: SparseArray<Parcelable>
257 private static final String RUNTIME_STATE_WIDGET_PANEL = "launcher.widget_panel";
Sunny Goyal17c72fb2019-10-14 14:06:38 -0700258
vadimt00d42552018-12-11 17:59:36 -0800259 public static final String ON_CREATE_EVT = "Launcher.onCreate";
Sunny Goyal17c72fb2019-10-14 14:06:38 -0700260 public static final String ON_START_EVT = "Launcher.onStart";
261 public static final String ON_RESUME_EVT = "Launcher.onResume";
262 public static final String ON_NEW_INTENT_EVT = "Launcher.onNewIntent";
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800263
Sunny Goyal35e7d382020-05-08 13:37:58 -0700264 private StateManager<LauncherState> mStateManager;
Patrick Dubroy6b509c12010-08-23 15:08:16 -0700265
Adam Cohenad4e15c2013-10-17 16:21:35 -0700266 private static final int ON_ACTIVITY_RESULT_ANIMATION_DELAY = 500;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800267
Winson Chunga2413752012-04-03 14:22:34 -0700268 // How long to wait before the new-shortcut animation automatically pans the workspace
Jon Mirandaf5197fc2019-09-04 16:55:41 -0700269 @VisibleForTesting public static final int NEW_APPS_PAGE_MOVE_DELAY = 500;
Rajeev Kumar43c0f582017-06-23 15:34:55 -0700270 private static final int NEW_APPS_ANIMATION_INACTIVE_TIMEOUT_SECONDS = 5;
Jon Mirandaf5197fc2019-09-04 16:55:41 -0700271 @Thunk @VisibleForTesting public static final int NEW_APPS_ANIMATION_DELAY = 500;
Winson Chunga2413752012-04-03 14:22:34 -0700272
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400273 private static final int APPS_VIEW_ALPHA_CHANNEL_INDEX = 1;
274 private static final int SCRIM_VIEW_ALPHA_CHANNEL_INDEX = 0;
275
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -0700276 private static final int THEME_CROSS_FADE_ANIMATION_DURATION = 375;
277
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800278 private Configuration mOldConfig;
Jon Miranda54441f52018-01-24 15:38:25 -0800279
Samuel Fufa37432442020-11-01 13:06:43 -0800280 private LiveSearchManager mLiveSearchManager;
281
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700282 @Thunk
283 Workspace mWorkspace;
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700284 @Thunk
285 DragLayer mDragLayer;
Michael Jurkab737ee62011-11-15 15:57:22 -0800286 private DragController mDragController;
Sunny Goyal322d5562015-06-25 19:35:49 -0700287
Sunny Goyal337c81f2019-12-10 12:19:13 -0800288 private WidgetManagerHelper mAppWidgetManager;
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700289 private LauncherAppWidgetHost mAppWidgetHost;
Romain Guycbb89e42009-06-08 15:52:54 -0700290
Rajeev Kumar43c0f582017-06-23 15:34:55 -0700291 private final int[] mTmpAddItemCellCoordinates = new int[2];
Michael Jurka0280c3b2010-09-17 15:00:07 -0700292
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700293 @Thunk
294 Hotseat mHotseat;
Adam Cohenf358a4b2013-07-23 16:47:31 -0700295
Sunny Goyal47328fd2016-05-25 18:56:41 -0700296 private DropTargetBar mDropTargetBar;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700297
298 // Main container view for the all apps screen.
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700299 @Thunk
300 AllAppsContainerView mAppsView;
Hyunyoung Song645764e2016-06-06 14:19:02 -0700301 AllAppsTransitionController mAllAppsController;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700302
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400303 // Scrim view for the all apps and overview state.
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700304 @Thunk
305 ScrimView mScrimView;
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400306
Winson Chung8ae41982017-11-10 11:42:13 -0800307 // UI and state for the overview panel
Sunny Goyal7c7be8c2018-03-07 19:58:07 -0800308 private View mOverviewPanel;
Winson Chung8ae41982017-11-10 11:42:13 -0800309
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700310 @Thunk
311 boolean mWorkspaceLoading = true;
Joe Onorato9c1289c2009-08-17 11:03:03 -0400312
Winson Chungc9bf6d42019-10-04 15:33:18 -0700313 // Used to notify when an activity launch has been deferred because launcher is not yet resumed
314 // TODO: See if we can remove this later
315 private Runnable mOnDeferredActivityLaunchCallback;
316
Sunny Goyal527c7d32015-08-28 15:19:36 -0700317 private ViewOnDrawExecutor mPendingExecutor;
Michael Jurka7607c2f2013-04-03 14:33:19 -0700318
Joe Onorato9c1289c2009-08-17 11:03:03 -0400319 private LauncherModel mModel;
Sunny Goyal43bf11d2017-02-02 13:52:53 -0800320 private ModelWriter mModelWriter;
Joe Onorato0589f0f2010-02-08 13:44:00 -0800321 private IconCache mIconCache;
Sunny Goyalae502842016-06-17 08:43:56 -0700322 private LauncherAccessibilityDelegate mAccessibilityDelegate;
Joe Onorato9c1289c2009-08-17 11:03:03 -0400323
Tony Wickham010d2552017-01-20 08:15:28 -0800324 private PopupDataProvider mPopupDataProvider;
Tony Wickhambfbf7f92016-05-19 11:19:39 -0700325
Sunny Goyalf4aceab2017-12-06 16:16:31 -0800326 private int mSynchronouslyBoundPage = PagedView.INVALID_PAGE;
Sunny Goyala7a5bf32020-01-05 15:35:29 +0530327 private int mPageToBindSynchronously = PagedView.INVALID_PAGE;
Adam Cohen1462de32012-07-24 22:34:36 -0700328
Winson Chung46353de2012-02-16 14:05:10 -0800329 // We only want to get the SharedPreferences once since it does an FS stat each time we get
330 // it from the context.
331 private SharedPreferences mSharedPrefs;
Tony Wickham133cd542020-04-08 17:48:41 -0700332 private OnboardingPrefs mOnboardingPrefs;
Winson Chung46353de2012-02-16 14:05:10 -0800333
Sunny Goyal2100c782016-08-22 16:00:03 -0700334 // Activity result which needs to be processed after workspace has loaded.
335 private ActivityResultInfo mPendingActivityResult;
336 /**
337 * Holds extra information required to handle a result from an external call, like
338 * {@link #startActivityForResult(Intent, int)} or {@link #requestPermissions(String[], int)}
339 */
340 private PendingRequestArgs mPendingRequestArgs;
Sunny Goyaldedda052019-05-14 15:23:48 -0700341 // Request id for any pending activity result
Sunny Goyal210e1742019-10-17 12:05:38 -0700342 protected int mPendingActivityRequestCode = -1;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800343
Tracy Zhou4d7b2442019-12-09 13:42:57 -0800344 private ViewGroupFocusHelper mFocusHandler;
Hyunyoung Song7fb3ccc2017-10-17 15:39:46 -0700345
Sunny Goyal623eddd2018-03-02 12:24:41 -0800346 private RotationHelper mRotationHelper;
Sunny Goyal7779d622015-06-11 16:18:39 -0700347
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400348 private float mCurrentAssistantVisibility = 0f;
349
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700350 protected LauncherOverlayManager mOverlayManager;
351 // If true, overlay callbacks are deferred
352 private boolean mDeferOverlayCallbacks;
353 private final Runnable mDeferredOverlayCallbacks = this::checkIfOverlayStillDeferred;
354
Riddle Hsu979da642020-09-22 21:52:40 +0800355 protected long mLastTouchUpTime = -1;
Sunny Goyala306e592020-03-24 01:51:41 -0700356 private boolean mTouchInProgress;
Sunny Goyal9b180102020-03-11 10:02:29 -0700357
Samuel Fufa41d909f2020-03-20 16:27:09 -0700358 private SafeCloseable mUserChangedCallbackCloseable;
359
thiruramc96873c2021-02-11 15:13:47 -0800360 // New InstanceId is assigned to mAllAppsSessionLogId for each AllApps sessions.
361 // When Launcher is not in AllApps state mAllAppsSessionLogId will be null.
362 // User actions within AllApps state are logged with this InstanceId, to recreate AllApps
363 // session on the server side.
364 protected InstanceId mAllAppsSessionLogId;
365 private LauncherState mPrevLauncherState;
366
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800367 @Override
368 protected void onCreate(Bundle savedInstanceState) {
Winson Chung5cc62c72019-10-16 11:32:41 -0700369 Object traceToken = TraceHelper.INSTANCE.beginSection(ON_CREATE_EVT,
370 TraceHelper.FLAG_UI_EVENT);
Winson Chunga2413752012-04-03 14:22:34 -0700371 if (DEBUG_STRICT_MODE) {
372 StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
373 .detectDiskReads()
374 .detectDiskWrites()
375 .detectNetwork() // or .detectAll() for all detectable problems
376 .penaltyLog()
377 .build());
378 StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
379 .detectLeakedSqlLiteObjects()
380 .detectLeakedClosableObjects()
381 .penaltyLog()
382 .penaltyDeath()
383 .build());
384 }
385
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800386 super.onCreate(savedInstanceState);
Daniel Sandlere060b0b2013-06-27 21:47:55 -0400387
Sunny Goyal87f784c2017-01-11 10:48:34 -0800388 LauncherAppState app = LauncherAppState.getInstance(this);
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800389 mOldConfig = new Configuration(getResources().getConfiguration());
Sunny Goyala7a5bf32020-01-05 15:35:29 +0530390 mModel = app.getModel();
Sunny Goyal9d89f752020-06-19 11:09:24 -0700391
Sunny Goyal41d51a02019-05-14 09:44:34 -0700392 mRotationHelper = new RotationHelper(this);
Hyunyoung Song31971a32019-01-27 12:31:12 -0800393 InvariantDeviceProfile idp = app.getInvariantDeviceProfile();
394 initDeviceProfile(idp);
395 idp.addOnChangeListener(this);
Sunny Goyalf7258242015-10-19 16:59:07 -0700396 mSharedPrefs = Utilities.getPrefs(this);
Joe Onorato0589f0f2010-02-08 13:44:00 -0800397 mIconCache = app.getIconCache();
Sunny Goyal384b5782021-02-09 22:50:02 -0800398 mAccessibilityDelegate = createAccessibilityDelegate();
Adam Cohen2e6da152015-05-06 11:42:25 -0700399
Joe Onorato41a12d22009-10-31 18:30:00 -0400400 mDragController = new DragController(this);
Hyunyoung Song645764e2016-06-06 14:19:02 -0700401 mAllAppsController = new AllAppsTransitionController(this);
Sunny Goyal35e7d382020-05-08 13:37:58 -0700402 mStateManager = new StateManager<>(this, NORMAL);
Romain Guycbb89e42009-06-08 15:52:54 -0700403
Sunny Goyal79e52fc2021-02-03 10:22:28 -0800404 mLiveSearchManager = new LiveSearchManager(this);
405
Sunny Goyal35e7d382020-05-08 13:37:58 -0700406 mOnboardingPrefs = createOnboardingPrefs(mSharedPrefs);
Tony Wickham133cd542020-04-08 17:48:41 -0700407
Sunny Goyal337c81f2019-12-10 12:19:13 -0800408 mAppWidgetManager = new WidgetManagerHelper(this);
Samuel Fufa44043ec2019-08-26 15:00:30 -0700409 mAppWidgetHost = new LauncherAppWidgetHost(this,
410 appWidgetId -> getWorkspace().removeWidget(appWidgetId));
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700411 mAppWidgetHost.startListening();
Romain Guycbb89e42009-06-08 15:52:54 -0700412
Sunny Goyal9d89f752020-06-19 11:09:24 -0700413 inflateRootView(R.layout.launcher);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800414 setupViews();
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -0700415 crossFadeWithPreviousAppearance();
Sunny Goyal9c2b9602020-01-07 13:07:55 -0800416 mPopupDataProvider = new PopupDataProvider(this::updateNotificationDots);
Tony Wickham010d2552017-01-20 08:15:28 -0800417
Sunny Goyale84c5b82019-09-26 17:05:31 -0700418 boolean internalStateHandled = ACTIVITY_TRACKER.handleCreate(this);
Sunny Goyald3864fa2017-11-14 15:06:36 -0800419 if (internalStateHandled) {
Sunny Goyald3864fa2017-11-14 15:06:36 -0800420 if (savedInstanceState != null) {
421 // InternalStateHandler has already set the appropriate state.
422 // We dont need to do anything.
423 savedInstanceState.remove(RUNTIME_STATE);
424 }
425 }
426 restoreState(savedInstanceState);
Sunny Goyalbbece862019-03-01 13:13:52 -0800427 mStateManager.reapplyState();
Winson Chungb63b44c2017-11-10 17:54:44 -0800428
Sunny Goyal2100c782016-08-22 16:00:03 -0700429 // We only load the page synchronously if the user rotates (or triggers a
430 // configuration change) while launcher is in the foreground
Sunny Goyala7a5bf32020-01-05 15:35:29 +0530431 int currentScreen = PagedView.INVALID_PAGE;
Sunny Goyalfe770c92016-09-27 14:38:58 -0700432 if (savedInstanceState != null) {
433 currentScreen = savedInstanceState.getInt(RUNTIME_STATE_CURRENT_SCREEN, currentScreen);
434 }
Sunny Goyala7a5bf32020-01-05 15:35:29 +0530435 mPageToBindSynchronously = currentScreen;
Sunny Goyald3864fa2017-11-14 15:06:36 -0800436
Sunny Goyala7a5bf32020-01-05 15:35:29 +0530437 if (!mModel.addCallbacksAndLoad(this)) {
Sunny Goyald3864fa2017-11-14 15:06:36 -0800438 if (!internalStateHandled) {
439 // If we are not binding synchronously, show a fade in animation when
440 // the first page bind completes.
Sunny Goyal6001ea22018-05-10 16:31:00 -0700441 mDragLayer.getAlphaProperty(ALPHA_INDEX_LAUNCHER_LOAD).setValue(0);
Sunny Goyald3864fa2017-11-14 15:06:36 -0800442 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800443 }
444
445 // For handling default keys
Sunny Goyalf4aceab2017-12-06 16:16:31 -0800446 setDefaultKeyMode(DEFAULT_KEYS_SEARCH_LOCAL);
Joe Onorato34a0e1b2009-12-14 17:44:51 -0800447
Sunny Goyal9d89f752020-06-19 11:09:24 -0700448 setContentView(getRootView());
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800449 getRootView().dispatchInsets();
Mario Bertschlera6936942017-05-31 14:48:19 -0700450
Jon Miranda7fda2852017-07-19 16:07:01 -0700451 // Listen for broadcasts
Sunny Goyal5d1873a2018-05-08 11:10:44 -0700452 registerReceiver(mScreenOffReceiver, new IntentFilter(Intent.ACTION_SCREEN_OFF));
Sunny Goyala616d2b2017-06-12 13:54:01 -0700453
Sunny Goyal8392c822017-06-20 10:03:56 -0700454 getSystemUiController().updateUiState(SystemUiController.UI_STATE_BASE_WINDOW,
455 Themes.getAttrBoolean(this, R.attr.isWorkspaceDarkText));
Sunny Goyal14b32402017-07-31 10:03:28 -0700456
457 if (mLauncherCallbacks != null) {
458 mLauncherCallbacks.onCreate(savedInstanceState);
459 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700460 mOverlayManager = getDefaultOverlay();
461 PluginManagerWrapper.INSTANCE.get(this).addPluginListener(this,
462 OverlayPlugin.class, false /* allowedMultiple */);
463
Sunny Goyal623eddd2018-03-02 12:24:41 -0800464 mRotationHelper.initialize();
Sunny Goyalfca6bc92017-09-28 16:28:34 -0700465
Sunny Goyal35e7d382020-05-08 13:37:58 -0700466 mStateManager.addStateListener(new StateListener<LauncherState>() {
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400467
468 @Override
469 public void onStateTransitionComplete(LauncherState finalState) {
470 float alpha = 1f - mCurrentAssistantVisibility;
471 if (finalState == NORMAL) {
472 mAppsView.getAlphaProperty(APPS_VIEW_ALPHA_CHANNEL_INDEX).setValue(alpha);
Tony Wickhamd844fe72020-08-13 19:33:26 -0700473 } else if (finalState == OVERVIEW) {
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400474 mAppsView.getAlphaProperty(APPS_VIEW_ALPHA_CHANNEL_INDEX).setValue(alpha);
Sunny Goyal52e25452020-07-20 12:38:01 -0700475 mScrimView.setAlpha(alpha);
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400476 } else {
477 mAppsView.getAlphaProperty(APPS_VIEW_ALPHA_CHANNEL_INDEX).setValue(1f);
Sunny Goyal52e25452020-07-20 12:38:01 -0700478 mScrimView.setAlpha(1f);
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400479 }
480 }
481 });
Sunny Goyal17c72fb2019-10-14 14:06:38 -0700482
Winson Chung5cc62c72019-10-16 11:32:41 -0700483 TraceHelper.INSTANCE.endSection(traceToken);
Samuel Fufa41d909f2020-03-20 16:27:09 -0700484
485 mUserChangedCallbackCloseable = UserCache.INSTANCE.get(this).addUserChangeListener(
486 () -> getStateManager().goToState(NORMAL));
Schneider Victor-tulias8a35c762020-09-03 14:30:10 -0700487
488 if (Utilities.ATLEAST_R) {
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -0700489 getWindow().setSoftInputMode(LayoutParams.SOFT_INPUT_ADJUST_NOTHING);
Schneider Victor-tulias8a35c762020-09-03 14:30:10 -0700490 }
Adam Cohen9211d422014-10-07 18:14:53 -0700491 }
492
Samuel Fufa37432442020-11-01 13:06:43 -0800493 public LiveSearchManager getLiveSearchManager() {
494 return mLiveSearchManager;
495 }
496
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700497 protected LauncherOverlayManager getDefaultOverlay() {
498 return new LauncherOverlayManager() { };
499 }
500
Sunny Goyal35e7d382020-05-08 13:37:58 -0700501 protected OnboardingPrefs createOnboardingPrefs(SharedPreferences sharedPrefs) {
502 return new OnboardingPrefs<>(this, sharedPrefs);
Tony Wickham133cd542020-04-08 17:48:41 -0700503 }
504
505 public OnboardingPrefs getOnboardingPrefs() {
506 return mOnboardingPrefs;
507 }
508
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700509 @Override
510 public void onPluginConnected(OverlayPlugin overlayManager, Context context) {
511 switchOverlay(() -> overlayManager.createOverlayManager(this, this));
512 }
513
514 @Override
515 public void onPluginDisconnected(OverlayPlugin plugin) {
516 switchOverlay(this::getDefaultOverlay);
517 }
518
519 private void switchOverlay(Supplier<LauncherOverlayManager> overlaySupplier) {
520 if (mOverlayManager != null) {
521 mOverlayManager.onActivityDestroyed(this);
522 }
523 mOverlayManager = overlaySupplier.get();
524 if (getRootView().isAttachedToWindow()) {
525 mOverlayManager.onAttachedToWindow();
526 }
527 mDeferOverlayCallbacks = true;
528 checkIfOverlayStillDeferred();
529 }
530
531 @Override
532 protected void dispatchDeviceProfileChanged() {
533 super.dispatchDeviceProfileChanged();
534 mOverlayManager.onDeviceProvideChanged();
535 }
536
Sunny Goyal7779d622015-06-11 16:18:39 -0700537 @Override
Winson Chung8eb49e02018-07-16 13:33:31 -0700538 public void onEnterAnimationComplete() {
539 super.onEnterAnimationComplete();
Sunny Goyalbe8c3402019-05-22 15:17:52 -0700540 mRotationHelper.setCurrentTransitionRequest(REQUEST_NONE);
Sunny Goyal30ac97d2020-06-24 23:47:46 -0700541 AbstractFloatingView.closeOpenViews(this, false, TYPE_ICON_SURFACE);
Winson Chung8eb49e02018-07-16 13:33:31 -0700542 }
543
544 @Override
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800545 public void onConfigurationChanged(Configuration newConfig) {
546 int diff = newConfig.diff(mOldConfig);
Jon Mirandaaeb4dd02018-07-11 14:16:23 -0700547
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800548 if ((diff & (CONFIG_ORIENTATION | CONFIG_SCREEN_SIZE)) != 0) {
Sunny Goyal371ea052019-03-06 15:38:32 -0800549 onIdpChanged(mDeviceProfile.inv);
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800550 }
551
552 mOldConfig.setTo(newConfig);
553 super.onConfigurationChanged(newConfig);
554 }
555
Sunny Goyal605bcf32018-03-02 15:16:12 -0800556 @Override
Hyunyoung Song31971a32019-01-27 12:31:12 -0800557 public void onIdpChanged(int changeFlags, InvariantDeviceProfile idp) {
Sunny Goyal371ea052019-03-06 15:38:32 -0800558 onIdpChanged(idp);
559 }
560
561 private void onIdpChanged(InvariantDeviceProfile idp) {
Sunny Goyal371ea052019-03-06 15:38:32 -0800562
Hyunyoung Song31971a32019-01-27 12:31:12 -0800563 initDeviceProfile(idp);
Sunny Goyal371ea052019-03-06 15:38:32 -0800564 dispatchDeviceProfileChanged();
565 reapplyUi();
566 mDragLayer.recreateControllers();
567
Sunny Goyal76ba0a32019-06-10 11:56:11 -0700568 // Calling onSaveInstanceState ensures that static cache used by listWidgets is
569 // initialized properly.
570 onSaveInstanceState(new Bundle());
Sunny Goyalc4d32012020-04-03 17:10:11 -0700571 mModel.rebindCallbacks();
Hyunyoung Song31971a32019-01-27 12:31:12 -0800572 }
573
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400574 public void onAssistantVisibilityChanged(float visibility) {
575 mCurrentAssistantVisibility = visibility;
576 float alpha = 1f - visibility;
577 LauncherState state = mStateManager.getState();
578 if (state == NORMAL) {
579 mAppsView.getAlphaProperty(APPS_VIEW_ALPHA_CHANNEL_INDEX).setValue(alpha);
Tony Wickhamd844fe72020-08-13 19:33:26 -0700580 } else if (state == OVERVIEW) {
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400581 mAppsView.getAlphaProperty(APPS_VIEW_ALPHA_CHANNEL_INDEX).setValue(alpha);
Sunny Goyal52e25452020-07-20 12:38:01 -0700582 mScrimView.setAlpha(alpha);
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400583 }
584 }
585
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800586 private void initDeviceProfile(InvariantDeviceProfile idp) {
587 // Load configuration-specific DeviceProfile
Sunny Goyal59d086c2018-05-07 17:31:40 -0700588 mDeviceProfile = idp.getDeviceProfile(this);
Sunny Goyal8c48d8b2019-01-25 15:10:18 -0800589 if (isInMultiWindowMode()) {
Sunny Goyal0addbf02020-04-28 14:17:35 -0700590 mDeviceProfile = mDeviceProfile.getMultiWindowProfile(
591 this, getMultiWindowDisplaySize());
Sunny Goyal59d086c2018-05-07 17:31:40 -0700592 }
Sunny Goyalae6e3182019-04-30 12:04:37 -0700593
Sunny Goyal59d086c2018-05-07 17:31:40 -0700594 onDeviceProfileInitiated();
Sunny Goyalc4d32012020-04-03 17:10:11 -0700595 mModelWriter = mModel.getWriter(getDeviceProfile().isVerticalBarLayout(), true);
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800596 }
597
Sunny Goyal623eddd2018-03-02 12:24:41 -0800598 public RotationHelper getRotationHelper() {
599 return mRotationHelper;
600 }
601
Tracy Zhou4d7b2442019-12-09 13:42:57 -0800602 public ViewGroupFocusHelper getFocusHandler() {
603 return mFocusHandler;
604 }
605
Sunny Goyal35e7d382020-05-08 13:37:58 -0700606 @Override
607 public StateManager<LauncherState> getStateManager() {
Sunny Goyal3e3f44c2017-10-23 17:14:52 -0700608 return mStateManager;
Sunny Goyalbe93f262017-10-20 17:05:27 -0700609 }
610
Adam Cohen9211d422014-10-07 18:14:53 -0700611 private LauncherCallbacks mLauncherCallbacks;
612
Sunny Goyal32554d12015-12-03 15:31:25 -0800613 /**
614 * Call this after onCreate to set or clear overlay.
615 */
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700616 @Override
Sunny Goyal32554d12015-12-03 15:31:25 -0800617 public void setLauncherOverlay(LauncherOverlay overlay) {
618 if (overlay != null) {
619 overlay.setOverlayCallbacks(new LauncherOverlayCallbacksImpl());
620 }
621 mWorkspace.setLauncherOverlay(overlay);
622 }
623
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700624 @Override
625 public void runOnOverlayHidden(Runnable runnable) {
626 getWorkspace().runOnOverlayHidden(runnable);
627 }
628
Adam Cohen9211d422014-10-07 18:14:53 -0700629 public boolean setLauncherCallbacks(LauncherCallbacks callbacks) {
630 mLauncherCallbacks = callbacks;
631 return true;
Adam Cohenf9426d52012-06-04 17:26:21 -0700632 }
633
Hyunyoung Song3f471442015-04-08 19:01:34 -0700634 public boolean isDraggingEnabled() {
Winson Chung36a62fe2012-05-06 18:04:42 -0700635 // We prevent dragging when we are loading the workspace as it is possible to pick up a view
636 // that is subsequently removed from the workspace in startBinding().
Sunny Goyal639e9062015-08-19 19:17:06 -0700637 return !isWorkspaceLoading();
Winson Chung36a62fe2012-05-06 18:04:42 -0700638 }
639
Tony Wickham010d2552017-01-20 08:15:28 -0800640 public PopupDataProvider getPopupDataProvider() {
641 return mPopupDataProvider;
642 }
643
Sunny Goyal0b0847b2018-03-14 12:30:11 -0700644 @Override
Tony Wickhamf34bee82018-12-03 18:11:39 -0800645 public DotInfo getDotInfoForItem(ItemInfo info) {
646 return mPopupDataProvider.getDotInfoForItem(info);
Sunny Goyal0b0847b2018-03-14 12:30:11 -0700647 }
648
649 @Override
650 public void invalidateParent(ItemInfo info) {
Jon Mirandae6f3fa42019-03-04 09:14:40 -0800651 if (info.container >= 0) {
Sunny Goyal0b0847b2018-03-14 12:30:11 -0700652 View folderIcon = getWorkspace().getHomescreenIconByItemId(info.container);
Jon Mirandae6f3fa42019-03-04 09:14:40 -0800653 if (folderIcon instanceof FolderIcon && folderIcon.getTag() instanceof FolderInfo) {
Sunny Goyal11a50742019-08-07 09:24:26 -0700654 if (new FolderGridOrganizer(getDeviceProfile().inv)
655 .setFolderInfo((FolderInfo) folderIcon.getTag())
656 .isItemInPreview(info.rank)) {
Jon Mirandae6f3fa42019-03-04 09:14:40 -0800657 folderIcon.invalidate();
658 }
Sunny Goyal0b0847b2018-03-14 12:30:11 -0700659 }
660 }
661 }
662
Adam Cohenc76e1dd2013-11-14 11:09:14 +0000663 /**
Winson Chung557d6ed2011-07-08 15:34:52 -0700664 * Returns whether we should delay spring loaded mode -- for shortcuts and widgets that have
665 * a configuration step, this allows the proper animations to run after other transitions.
666 */
Sunny Goyalefb7e842018-10-04 15:11:00 -0700667 private int completeAdd(
Sunny Goyal2100c782016-08-22 16:00:03 -0700668 int requestCode, Intent intent, int appWidgetId, PendingRequestArgs info) {
Sunny Goyalefb7e842018-10-04 15:11:00 -0700669 int screenId = info.screenId;
Sunny Goyal2100c782016-08-22 16:00:03 -0700670 if (info.container == LauncherSettings.Favorites.CONTAINER_DESKTOP) {
Adam Cohen83079e42014-09-19 17:43:08 -0700671 // When the screen id represents an actual screen (as opposed to a rank) we make sure
672 // that the drop page actually exists.
Sunny Goyal2100c782016-08-22 16:00:03 -0700673 screenId = ensurePendingDropLayoutExists(info.screenId);
Adam Cohen83079e42014-09-19 17:43:08 -0700674 }
Adam Cohendb364c32014-05-20 14:23:40 -0700675
Sunny Goyal2100c782016-08-22 16:00:03 -0700676 switch (requestCode) {
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800677 case REQUEST_CREATE_SHORTCUT:
Sunny Goyalfb5096d2016-09-08 14:32:06 -0700678 completeAddShortcut(intent, info.container, screenId, info.cellX, info.cellY, info);
Pinyao Tingc9074272019-11-11 11:51:44 -0800679 announceForAccessibility(R.string.item_added_to_workspace);
Winson Chungb8472bb2011-08-05 13:49:21 -0700680 break;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800681 case REQUEST_CREATE_APPWIDGET:
Sunny Goyal2100c782016-08-22 16:00:03 -0700682 completeAddAppWidget(appWidgetId, info, null, null);
Winson Chungb8472bb2011-08-05 13:49:21 -0700683 break;
Sunny Goyalff572272014-07-23 13:58:07 -0700684 case REQUEST_RECONFIGURE_APPWIDGET:
Sunny Goyal2100c782016-08-22 16:00:03 -0700685 completeRestoreAppWidget(appWidgetId, LauncherAppWidgetInfo.RESTORE_COMPLETED);
Sunny Goyalff572272014-07-23 13:58:07 -0700686 break;
Sunny Goyald478c832016-04-01 12:04:16 -0700687 case REQUEST_BIND_PENDING_APPWIDGET: {
Sunny Goyal2100c782016-08-22 16:00:03 -0700688 int widgetId = appWidgetId;
689 LauncherAppWidgetInfo widgetInfo =
Sunny Goyald478c832016-04-01 12:04:16 -0700690 completeRestoreAppWidget(widgetId, LauncherAppWidgetInfo.FLAG_UI_NOT_READY);
Sunny Goyal2100c782016-08-22 16:00:03 -0700691 if (widgetInfo != null) {
Sunny Goyald478c832016-04-01 12:04:16 -0700692 // Since the view was just bound, also launch the configure activity if needed
693 LauncherAppWidgetProviderInfo provider = mAppWidgetManager
694 .getLauncherAppWidgetInfo(widgetId);
Sunny Goyal04a324a2017-01-20 21:08:59 -0800695 if (provider != null) {
696 new WidgetAddFlowHandler(provider)
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700697 .startConfigActivity(this, widgetInfo,
698 REQUEST_RECONFIGURE_APPWIDGET);
Sunny Goyald478c832016-04-01 12:04:16 -0700699 }
700 }
701 break;
702 }
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800703 }
Adam Cohendb364c32014-05-20 14:23:40 -0700704 return screenId;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800705 }
706
Adam Cohenc7cd2cb2014-11-17 17:45:34 -0800707 private void handleActivityResult(
Michael Jurka8b805b12012-04-18 14:23:14 -0700708 final int requestCode, final int resultCode, final Intent data) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700709 if (isWorkspaceLoading()) {
710 // process the result once the workspace has loaded.
711 mPendingActivityResult = new ActivityResultInfo(requestCode, resultCode, data);
712 return;
713 }
714 mPendingActivityResult = null;
715
Winson Chunge341d302013-08-16 14:31:00 -0700716 // Reset the startActivity waiting flag
Sunny Goyal2100c782016-08-22 16:00:03 -0700717 final PendingRequestArgs requestArgs = mPendingRequestArgs;
718 setWaitingForResult(null);
719 if (requestArgs == null) {
720 return;
721 }
722
723 final int pendingAddWidgetId = requestArgs.getWidgetId();
Winson Chunge341d302013-08-16 14:31:00 -0700724
Adam Cohenad4e15c2013-10-17 16:21:35 -0700725 Runnable exitSpringLoaded = new Runnable() {
726 @Override
727 public void run() {
Sunny Goyal3e3f44c2017-10-23 17:14:52 -0700728 mStateManager.goToState(NORMAL, SPRING_LOADED_EXIT_DELAY);
Adam Cohenad4e15c2013-10-17 16:21:35 -0700729 }
730 };
731
Michael Jurka8b805b12012-04-18 14:23:14 -0700732 if (requestCode == REQUEST_BIND_APPWIDGET) {
Winsona1f79d32015-08-05 14:00:45 -0700733 // This is called only if the user did not previously have permissions to bind widgets
Adam Cohenad4e15c2013-10-17 16:21:35 -0700734 final int appWidgetId = data != null ?
Michael Jurka8b805b12012-04-18 14:23:14 -0700735 data.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1) : -1;
736 if (resultCode == RESULT_CANCELED) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700737 completeTwoStageWidgetDrop(RESULT_CANCELED, appWidgetId, requestArgs);
Sunny Goyal6e379fc2020-03-19 16:08:14 -0700738 mWorkspace.removeExtraEmptyScreenDelayed(
739 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false, exitSpringLoaded);
Michael Jurka8b805b12012-04-18 14:23:14 -0700740 } else if (resultCode == RESULT_OK) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700741 addAppWidgetImpl(
742 appWidgetId, requestArgs, null,
Sunny Goyal04a324a2017-01-20 21:08:59 -0800743 requestArgs.getWidgetHandler(),
Sunny Goyal2100c782016-08-22 16:00:03 -0700744 ON_ACTIVITY_RESULT_ANIMATION_DELAY);
Michael Jurka8b805b12012-04-18 14:23:14 -0700745 }
746 return;
747 }
Michael Jurka336fd4f2013-09-12 00:05:02 +0200748
Adam Cohened66b2b2012-01-23 17:28:51 -0800749 boolean isWidgetDrop = (requestCode == REQUEST_PICK_APPWIDGET ||
Sunny Goyal5c97f512015-05-19 16:03:28 -0700750 requestCode == REQUEST_CREATE_APPWIDGET);
Romain Guyaad5ef42009-06-10 02:48:37 -0700751
Adam Cohened66b2b2012-01-23 17:28:51 -0800752 // We have special handling for widgets
753 if (isWidgetDrop) {
Adam Cohen4637b5a2013-11-04 18:21:24 -0800754 final int appWidgetId;
755 int widgetId = data != null ? data.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1)
756 : -1;
757 if (widgetId < 0) {
758 appWidgetId = pendingAddWidgetId;
759 } else {
760 appWidgetId = widgetId;
761 }
762
Adam Cohenad4e15c2013-10-17 16:21:35 -0700763 final int result;
Adam Cohenf0129b12013-11-04 17:57:36 -0800764 if (appWidgetId < 0 || resultCode == RESULT_CANCELED) {
Adam Cohendb364c32014-05-20 14:23:40 -0700765 Log.e(TAG, "Error: appWidgetId (EXTRA_APPWIDGET_ID) was not " +
766 "returned from the widget configuration activity.");
Adam Cohenad4e15c2013-10-17 16:21:35 -0700767 result = RESULT_CANCELED;
Sunny Goyal2100c782016-08-22 16:00:03 -0700768 completeTwoStageWidgetDrop(result, appWidgetId, requestArgs);
Sunny Goyal6e379fc2020-03-19 16:08:14 -0700769 mWorkspace.removeExtraEmptyScreenDelayed(
770 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false,
771 () -> getStateManager().goToState(NORMAL));
Sunny Goyal2100c782016-08-22 16:00:03 -0700772 } else {
773 if (requestArgs.container == LauncherSettings.Favorites.CONTAINER_DESKTOP) {
774 // When the screen id represents an actual screen (as opposed to a rank)
775 // we make sure that the drop page actually exists.
776 requestArgs.screenId =
777 ensurePendingDropLayoutExists(requestArgs.screenId);
Adam Cohendb364c32014-05-20 14:23:40 -0700778 }
Sunny Goyal2100c782016-08-22 16:00:03 -0700779 final CellLayout dropLayout =
780 mWorkspace.getScreenWithId(requestArgs.screenId);
781
782 dropLayout.setDropPending(true);
783 final Runnable onComplete = new Runnable() {
784 @Override
785 public void run() {
786 completeTwoStageWidgetDrop(resultCode, appWidgetId, requestArgs);
787 dropLayout.setDropPending(false);
788 }
789 };
Sunny Goyal6e379fc2020-03-19 16:08:14 -0700790 mWorkspace.removeExtraEmptyScreenDelayed(
791 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false, onComplete);
Winson Chung5aaab772012-04-27 15:24:02 -0700792 }
Adam Cohened66b2b2012-01-23 17:28:51 -0800793 return;
794 }
795
Sunny Goyald478c832016-04-01 12:04:16 -0700796 if (requestCode == REQUEST_RECONFIGURE_APPWIDGET
797 || requestCode == REQUEST_BIND_PENDING_APPWIDGET) {
Sunny Goyalff572272014-07-23 13:58:07 -0700798 if (resultCode == RESULT_OK) {
799 // Update the widget view.
Sunny Goyal2100c782016-08-22 16:00:03 -0700800 completeAdd(requestCode, data, pendingAddWidgetId, requestArgs);
Sunny Goyalff572272014-07-23 13:58:07 -0700801 }
802 // Leave the widget in the pending state if the user canceled the configure.
803 return;
804 }
805
Sunny Goyalaad90582015-07-09 14:22:50 -0700806 if (requestCode == REQUEST_CREATE_SHORTCUT) {
807 // Handle custom shortcuts created using ACTION_CREATE_SHORTCUT.
Sunny Goyal2100c782016-08-22 16:00:03 -0700808 if (resultCode == RESULT_OK && requestArgs.container != ItemInfo.NO_ID) {
809 completeAdd(requestCode, data, -1, requestArgs);
Sunny Goyal6e379fc2020-03-19 16:08:14 -0700810 mWorkspace.removeExtraEmptyScreenDelayed(
811 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false, exitSpringLoaded);
Sunny Goyal2100c782016-08-22 16:00:03 -0700812
Sunny Goyalaad90582015-07-09 14:22:50 -0700813 } else if (resultCode == RESULT_CANCELED) {
Sunny Goyal6e379fc2020-03-19 16:08:14 -0700814 mWorkspace.removeExtraEmptyScreenDelayed(
815 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false, exitSpringLoaded);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800816 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800817 }
Hongming Jind91cb6e2020-01-27 16:23:03 -0800818
Adam Cohened66b2b2012-01-23 17:28:51 -0800819 mDragLayer.clearAnimatedView();
Adam Cohenc7cd2cb2014-11-17 17:45:34 -0800820 }
821
822 @Override
Sunny Goyal64a75aa2017-07-03 13:50:52 -0700823 public void onActivityResult(
Adam Cohenc7cd2cb2014-11-17 17:45:34 -0800824 final int requestCode, final int resultCode, final Intent data) {
Sunny Goyaldedda052019-05-14 15:23:48 -0700825 mPendingActivityRequestCode = -1;
Adam Cohenc7cd2cb2014-11-17 17:45:34 -0800826 handleActivityResult(requestCode, resultCode, data);
Adam Cohened66b2b2012-01-23 17:28:51 -0800827 }
828
Sunny Goyal7ce471b2017-08-02 03:37:39 -0700829 @Override
Sunny Goyaldd2e6df2015-07-07 10:57:57 -0700830 public void onRequestPermissionsResult(int requestCode, String[] permissions,
Dave Hawkey3a43ed62015-06-26 10:27:47 -0600831 int[] grantResults) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700832 PendingRequestArgs pendingArgs = mPendingRequestArgs;
833 if (requestCode == REQUEST_PERMISSION_CALL_PHONE && pendingArgs != null
834 && pendingArgs.getRequestCode() == REQUEST_PERMISSION_CALL_PHONE) {
835 setWaitingForResult(null);
836
Sunny Goyal28c6b962015-10-12 11:42:05 -0700837 View v = null;
Sunny Goyal2100c782016-08-22 16:00:03 -0700838 CellLayout layout = getCellLayout(pendingArgs.container, pendingArgs.screenId);
Sunny Goyal28c6b962015-10-12 11:42:05 -0700839 if (layout != null) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700840 v = layout.getChildAt(pendingArgs.cellX, pendingArgs.cellY);
Sunny Goyal28c6b962015-10-12 11:42:05 -0700841 }
Sunny Goyal2100c782016-08-22 16:00:03 -0700842 Intent intent = pendingArgs.getPendingIntent();
843
Sunny Goyal28c6b962015-10-12 11:42:05 -0700844 if (grantResults.length > 0
845 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
Sunny Goyal852537f2020-07-15 17:02:16 -0700846 startActivitySafely(v, intent, null);
Sunny Goyal28c6b962015-10-12 11:42:05 -0700847 } else {
848 // TODO: Show a snack bar with link to settings
849 Toast.makeText(this, getString(R.string.msg_no_phone_permission,
Sunny Goyal112ce422016-08-22 16:45:29 -0700850 getString(R.string.derived_app_name)), Toast.LENGTH_SHORT).show();
Sunny Goyal28c6b962015-10-12 11:42:05 -0700851 }
852 }
Dave Hawkey3a43ed62015-06-26 10:27:47 -0600853 }
854
Adam Cohendb364c32014-05-20 14:23:40 -0700855 /**
856 * Check to see if a given screen id exists. If not, create it at the end, return the new id.
857 *
858 * @param screenId the screen id to check
859 * @return the new screen, or screenId if it exists
860 */
Sunny Goyalefb7e842018-10-04 15:11:00 -0700861 private int ensurePendingDropLayoutExists(int screenId) {
Sunny Goyal32554d12015-12-03 15:31:25 -0800862 CellLayout dropLayout = mWorkspace.getScreenWithId(screenId);
Adam Cohendb364c32014-05-20 14:23:40 -0700863 if (dropLayout == null) {
864 // it's possible that the add screen was removed because it was
865 // empty and a re-bind occurred
866 mWorkspace.addExtraEmptyScreen();
867 return mWorkspace.commitExtraEmptyScreen();
868 } else {
869 return screenId;
870 }
871 }
872
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700873 @Thunk
874 void completeTwoStageWidgetDrop(
Sunny Goyal2100c782016-08-22 16:00:03 -0700875 final int resultCode, final int appWidgetId, final PendingRequestArgs requestArgs) {
876 CellLayout cellLayout = mWorkspace.getScreenWithId(requestArgs.screenId);
Adam Cohened66b2b2012-01-23 17:28:51 -0800877 Runnable onCompleteRunnable = null;
878 int animationType = 0;
879
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700880 AppWidgetHostView boundWidget = null;
Adam Cohened66b2b2012-01-23 17:28:51 -0800881 if (resultCode == RESULT_OK) {
882 animationType = Workspace.COMPLETE_TWO_STAGE_WIDGET_DROP_ANIMATION;
883 final AppWidgetHostView layout = mAppWidgetHost.createView(this, appWidgetId,
Sunny Goyal04a324a2017-01-20 21:08:59 -0800884 requestArgs.getWidgetHandler().getProviderInfo(this));
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700885 boundWidget = layout;
Adam Cohened66b2b2012-01-23 17:28:51 -0800886 onCompleteRunnable = new Runnable() {
887 @Override
888 public void run() {
Sunny Goyal2100c782016-08-22 16:00:03 -0700889 completeAddAppWidget(appWidgetId, requestArgs, layout, null);
Sunny Goyal3e3f44c2017-10-23 17:14:52 -0700890 mStateManager.goToState(NORMAL, SPRING_LOADED_EXIT_DELAY);
Adam Cohened66b2b2012-01-23 17:28:51 -0800891 }
892 };
893 } else if (resultCode == RESULT_CANCELED) {
Adam Cohen4637b5a2013-11-04 18:21:24 -0800894 mAppWidgetHost.deleteAppWidgetId(appWidgetId);
Adam Cohened66b2b2012-01-23 17:28:51 -0800895 animationType = Workspace.CANCEL_TWO_STAGE_WIDGET_DROP_ANIMATION;
Adam Cohened66b2b2012-01-23 17:28:51 -0800896 }
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700897 if (mDragLayer.getAnimatedView() != null) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700898 mWorkspace.animateWidgetDrop(requestArgs, cellLayout,
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700899 (DragView) mDragLayer.getAnimatedView(), onCompleteRunnable,
900 animationType, boundWidget, true);
Adam Cohenad4e15c2013-10-17 16:21:35 -0700901 } else if (onCompleteRunnable != null) {
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700902 // The animated view may be null in the case of a rotation during widget configuration
903 onCompleteRunnable.run();
904 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800905 }
906
907 @Override
Michael Jurkacd496d72013-04-11 11:32:45 -0700908 protected void onStop() {
909 super.onStop();
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700910 if (mDeferOverlayCallbacks) {
911 checkIfOverlayStillDeferred();
912 } else {
913 mOverlayManager.onActivityStopped(this);
Adam Cohen9211d422014-10-07 18:14:53 -0700914 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700915
Hyunyoung Song95786e02020-09-15 00:34:10 -0700916 logStopAndResume(false /* isResume */);
vadimt04ebcf42021-02-03 15:31:51 -0800917 mAppWidgetHost.setActivityStarted(false);
Tony Wickham010d2552017-01-20 08:15:28 -0800918 NotificationListener.removeNotificationsChangedListener();
Michael Jurkacd496d72013-04-11 11:32:45 -0700919 }
920
921 @Override
922 protected void onStart() {
Winson Chung5cc62c72019-10-16 11:32:41 -0700923 Object traceToken = TraceHelper.INSTANCE.beginSection(ON_START_EVT,
924 TraceHelper.FLAG_UI_EVENT);
Michael Jurkacd496d72013-04-11 11:32:45 -0700925 super.onStart();
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700926 if (!mDeferOverlayCallbacks) {
927 mOverlayManager.onActivityStarted(this);
Adam Cohen9211d422014-10-07 18:14:53 -0700928 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700929
vadimt04ebcf42021-02-03 15:31:51 -0800930 mAppWidgetHost.setActivityStarted(true);
Winson Chung5cc62c72019-10-16 11:32:41 -0700931 TraceHelper.INSTANCE.endSection(traceToken);
Michael Jurkacd496d72013-04-11 11:32:45 -0700932 }
933
Sunny Goyal35e7d382020-05-08 13:37:58 -0700934 @Override
935 @CallSuper
936 protected void onDeferredResumed() {
Hyunyoung Song95786e02020-09-15 00:34:10 -0700937 logStopAndResume(true /* isResume */);
Sunny Goyala002c6c2019-02-12 16:20:10 -0800938
Sunny Goyal35e7d382020-05-08 13:37:58 -0700939 // Process any items that were added while Launcher was away.
Sunny Goyal60e68c92020-08-12 13:59:27 -0700940 ItemInstallQueue.INSTANCE.get(this)
941 .resumeModelPush(FLAG_ACTIVITY_PAUSED);
Sunny Goyale9c6f4c2019-05-30 11:35:25 -0700942
Sunny Goyal35e7d382020-05-08 13:37:58 -0700943 // Refresh shortcuts if the permission changed.
Sunny Goyal8b74cc72020-07-27 17:50:33 -0700944 mModel.validateModelDataOnResume();
Sunny Goyale9c6f4c2019-05-30 11:35:25 -0700945
Sunny Goyal35e7d382020-05-08 13:37:58 -0700946 // Set the notification listener and fetch updated notifications when we resume
947 NotificationListener.setNotificationsChangedListener(mPopupDataProvider);
Winson Chung87583112019-06-10 14:20:58 -0700948
Sunny Goyal35e7d382020-05-08 13:37:58 -0700949 DiscoveryBounce.showForHomeIfNeeded(this);
vadimt04ebcf42021-02-03 15:31:51 -0800950 mAppWidgetHost.setActivityResumed(true);
Sunny Goyaldedda052019-05-14 15:23:48 -0700951 }
952
Hyunyoung Song95786e02020-09-15 00:34:10 -0700953 private void logStopAndResume(boolean isResume) {
Hyunyoung Song77e29772020-08-25 00:53:48 -0700954 if (mPendingExecutor != null) return;
Hyunyoung Song801f81f2020-06-19 02:58:53 -0700955 int pageIndex = mWorkspace.isOverlayShown() ? -1 : mWorkspace.getCurrentPage();
Hyunyoung Song95786e02020-09-15 00:34:10 -0700956 int statsLogOrdinal = mStateManager.getState().statsLogOrdinal;
Hyunyoung Song801f81f2020-06-19 02:58:53 -0700957
958 StatsLogManager.EventEnum event;
959 StatsLogManager.StatsLogger logger = getStatsLogManager().logger();
Hyunyoung Song95786e02020-09-15 00:34:10 -0700960 if (isResume) {
Hyunyoung Song801f81f2020-06-19 02:58:53 -0700961 logger.withSrcState(LAUNCHER_STATE_BACKGROUND)
Hyunyoung Song95786e02020-09-15 00:34:10 -0700962 .withDstState(mStateManager.getState().statsLogOrdinal);
Hyunyoung Song801f81f2020-06-19 02:58:53 -0700963 event = LAUNCHER_ONRESUME;
964 } else { /* command == Action.Command.STOP */
Hyunyoung Song95786e02020-09-15 00:34:10 -0700965 logger.withSrcState(mStateManager.getState().statsLogOrdinal)
Hyunyoung Song801f81f2020-06-19 02:58:53 -0700966 .withDstState(LAUNCHER_STATE_BACKGROUND);
967 event = LAUNCHER_ONSTOP;
968 }
969
Hyunyoung Song95786e02020-09-15 00:34:10 -0700970 if (statsLogOrdinal == LAUNCHER_STATE_HOME && mWorkspace != null) {
Hyunyoung Song801f81f2020-06-19 02:58:53 -0700971 logger.withContainerInfo(LauncherAtom.ContainerInfo.newBuilder()
972 .setWorkspace(
973 LauncherAtom.WorkspaceContainer.newBuilder()
974 .setPageIndex(pageIndex)).build());
Becky Qiubfc2da12019-08-01 11:09:38 -0700975 }
Hyunyoung Song801f81f2020-06-19 02:58:53 -0700976 logger.log(event);
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700977 }
Becky Qiubfc2da12019-08-01 11:09:38 -0700978
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700979 private void scheduleDeferredCheck() {
980 mHandler.removeCallbacks(mDeferredOverlayCallbacks);
981 postAsyncCallback(mHandler, mDeferredOverlayCallbacks);
982 }
983
984 private void checkIfOverlayStillDeferred() {
985 if (!mDeferOverlayCallbacks) {
986 return;
987 }
Sunny Goyal8f965462020-04-23 19:00:36 -0700988 if (isStarted() && (!hasBeenResumed()
989 || mStateManager.getState().hasFlag(FLAG_NON_INTERACTIVE))) {
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700990 return;
991 }
992 mDeferOverlayCallbacks = false;
993
994 // Move the client to the correct state. Calling the same method twice is no-op.
995 if (isStarted()) {
996 mOverlayManager.onActivityStarted(this);
997 }
998 if (hasBeenResumed()) {
999 mOverlayManager.onActivityResumed(this);
1000 } else {
1001 mOverlayManager.onActivityPaused(this);
1002 }
1003 if (!isStarted()) {
1004 mOverlayManager.onActivityStopped(this);
1005 }
1006 }
1007
1008 public void deferOverlayCallbacksUntilNextResumeOrStop() {
1009 mDeferOverlayCallbacks = true;
1010 }
1011
1012 public LauncherOverlayManager getOverlayManager() {
1013 return mOverlayManager;
Becky Qiubfc2da12019-08-01 11:09:38 -07001014 }
1015
Sunny Goyal35e7d382020-05-08 13:37:58 -07001016 @Override
Winson Chungef528762019-09-06 12:05:52 -07001017 public void onStateSetStart(LauncherState state) {
Sunny Goyal35e7d382020-05-08 13:37:58 -07001018 super.onStateSetStart(state);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001019 if (mDeferOverlayCallbacks) {
1020 scheduleDeferredCheck();
Sunny Goyale9c6f4c2019-05-30 11:35:25 -07001021 }
Sunny Goyal210e1742019-10-17 12:05:38 -07001022 addActivityFlags(ACTIVITY_STATE_TRANSITION_ACTIVE);
Sunny Goyal8f965462020-04-23 19:00:36 -07001023
1024 if (state.hasFlag(FLAG_CLOSE_POPUPS)) {
1025 AbstractFloatingView.closeAllOpenViews(this, !state.hasFlag(FLAG_NON_INTERACTIVE));
1026 }
1027
1028 if (state == SPRING_LOADED) {
1029 // Prevent any Un/InstallShortcutReceivers from updating the db while we are
1030 // not on homescreen
Sunny Goyal60e68c92020-08-12 13:59:27 -07001031 ItemInstallQueue.INSTANCE.get(this).pauseModelPush(FLAG_DRAG_AND_DROP);
Sunny Goyal8f965462020-04-23 19:00:36 -07001032 getRotationHelper().setCurrentStateRequest(REQUEST_LOCK);
1033
1034 mWorkspace.showPageIndicatorAtCurrentScroll();
1035 mWorkspace.setClipChildren(false);
1036 }
1037 // When multiple pages are visible, show persistent page indicator
1038 mWorkspace.getPageIndicator().setShouldAutoHide(!state.hasFlag(FLAG_MULTI_PAGE));
thiruramc96873c2021-02-11 15:13:47 -08001039 mPrevLauncherState = mStateManager.getCurrentStableState();
Sunny Goyaldedda052019-05-14 15:23:48 -07001040 }
1041
Sunny Goyal35e7d382020-05-08 13:37:58 -07001042 @Override
Winson Chungef528762019-09-06 12:05:52 -07001043 public void onStateSetEnd(LauncherState state) {
Sunny Goyalfee1b252020-12-14 12:30:38 -08001044 super.onStateSetEnd(state);
vadimt04ebcf42021-02-03 15:31:51 -08001045 getAppWidgetHost().setStateIsNormal(state == LauncherState.NORMAL);
Sunny Goyal8f965462020-04-23 19:00:36 -07001046 getWorkspace().setClipChildren(!state.hasFlag(FLAG_MULTI_PAGE));
1047
Winson Chungef528762019-09-06 12:05:52 -07001048 finishAutoCancelActionMode();
Sunny Goyal210e1742019-10-17 12:05:38 -07001049 removeActivityFlags(ACTIVITY_STATE_TRANSITION_ACTIVE);
Sunny Goyal8f965462020-04-23 19:00:36 -07001050
1051 // dispatch window state changed
1052 getWindow().getDecorView().sendAccessibilityEvent(TYPE_WINDOW_STATE_CHANGED);
1053 AccessibilityManagerCompat.sendStateEventToTest(this, state.ordinal);
1054
1055 if (state == NORMAL) {
1056 // Re-enable any Un/InstallShortcutReceiver and now process any queued items
Sunny Goyal60e68c92020-08-12 13:59:27 -07001057 ItemInstallQueue.INSTANCE.get(this)
1058 .resumeModelPush(FLAG_DRAG_AND_DROP);
Sunny Goyal8f965462020-04-23 19:00:36 -07001059
1060 // Clear any rotation locks when going to normal state
1061 getRotationHelper().setCurrentStateRequest(REQUEST_NONE);
1062 }
thiruramc96873c2021-02-11 15:13:47 -08001063
1064 if (ALL_APPS.equals(state)) {
1065 // creates new instance ID since new all apps session is started.
1066 mAllAppsSessionLogId = new InstanceIdSequence().newInstanceId();
thiruram9f53d612021-02-24 10:54:01 -08001067 getStatsLogManager()
1068 .logger()
1069 .log(FeatureFlags.ENABLE_DEVICE_SEARCH.get()
1070 ? LAUNCHER_ALLAPPS_ENTRY_WITH_DEVICE_SEARCH
1071 : LAUNCHER_ALLAPPS_ENTRY);
thiruramc96873c2021-02-11 15:13:47 -08001072 } else if (ALL_APPS.equals(mPrevLauncherState)
1073 // Check if mLogInstanceId is not null to make sure exit event is logged only once.
1074 && mAllAppsSessionLogId != null) {
1075 getStatsLogManager().logger().log(LAUNCHER_ALLAPPS_EXIT);
1076 mAllAppsSessionLogId = null;
1077 }
Winson Chungef528762019-09-06 12:05:52 -07001078 }
1079
Michael Jurkacd496d72013-04-11 11:32:45 -07001080 @Override
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001081 protected void onResume() {
Winson Chung5cc62c72019-10-16 11:32:41 -07001082 Object traceToken = TraceHelper.INSTANCE.beginSection(ON_RESUME_EVT,
1083 TraceHelper.FLAG_UI_EVENT);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001084 super.onResume();
Sunny Goyalfca6bc92017-09-28 16:28:34 -07001085
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001086 if (mDeferOverlayCallbacks) {
1087 scheduleDeferredCheck();
1088 } else {
1089 mOverlayManager.onActivityResumed(this);
Adam Cohen9211d422014-10-07 18:14:53 -07001090 }
Mario Bertschler0fc6f682017-02-17 12:16:13 -08001091
Winson Chung5cc62c72019-10-16 11:32:41 -07001092 TraceHelper.INSTANCE.endSection(traceToken);
Adam Cohen06dff352012-06-01 17:17:08 -07001093 }
1094
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001095 @Override
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001096 protected void onPause() {
Winson Chung997a9232013-07-24 15:33:46 -07001097 // Ensure that items added to Launcher are queued until Launcher returns
Sunny Goyal60e68c92020-08-12 13:59:27 -07001098 ItemInstallQueue.INSTANCE.get(this).pauseModelPush(FLAG_ACTIVITY_PAUSED);
Winson Chung997a9232013-07-24 15:33:46 -07001099
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001100 super.onPause();
Joe Onorato24b6fd82009-11-12 13:47:09 -08001101 mDragController.cancelDrag();
Sunny Goyal9b180102020-03-11 10:02:29 -07001102 mLastTouchUpTime = -1;
Hyunyoung Song497708c2019-05-01 16:16:53 -07001103 mDropTargetBar.animateToVisibility(false);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001104
1105 if (!mDeferOverlayCallbacks) {
1106 mOverlayManager.onActivityPaused(this);
Adam Cohenbffe7452013-07-22 18:21:45 -07001107 }
vadimt04ebcf42021-02-03 15:31:51 -08001108 mAppWidgetHost.setActivityResumed(false);
Adam Cohenbffe7452013-07-22 18:21:45 -07001109 }
1110
Adam Cohenc2d6e892014-10-16 09:49:24 -07001111 class LauncherOverlayCallbacksImpl implements LauncherOverlayCallbacks {
1112
Sunny Goyalc86df472016-02-25 09:19:38 -08001113 public void onScrollChanged(float progress) {
1114 if (mWorkspace != null) {
1115 mWorkspace.onOverlayScrollChanged(progress);
1116 }
1117 }
Adam Cohenc2d6e892014-10-16 09:49:24 -07001118 }
1119
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001120 /**
1121 * Restores the previous state, if it exists.
1122 *
1123 * @param savedState The previous state.
1124 */
1125 private void restoreState(Bundle savedState) {
1126 if (savedState == null) {
1127 return;
1128 }
1129
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001130 int stateOrdinal = savedState.getInt(RUNTIME_STATE, NORMAL.ordinal);
Sunny Goyalf9403d92017-10-18 10:55:56 -07001131 LauncherState[] stateValues = LauncherState.values();
1132 LauncherState state = stateValues[stateOrdinal];
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08001133
1134 NonConfigInstance lastInstance = (NonConfigInstance) getLastNonConfigurationInstance();
1135 boolean forceRestore = lastInstance != null
1136 && (lastInstance.config.diff(mOldConfig) & CONFIG_UI_MODE) != 0;
1137 if (forceRestore || !state.shouldDisableRestore()) {
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001138 mStateManager.goToState(state, false /* animated */);
Joe Onorato3a8820b2009-11-10 15:06:42 -08001139 }
1140
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001141 PendingRequestArgs requestArgs = savedState.getParcelable(
1142 RUNTIME_STATE_PENDING_REQUEST_ARGS);
Sunny Goyal2100c782016-08-22 16:00:03 -07001143 if (requestArgs != null) {
1144 setWaitingForResult(requestArgs);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001145 }
Sunny Goyaldedda052019-05-14 15:23:48 -07001146 mPendingActivityRequestCode = savedState.getInt(RUNTIME_STATE_PENDING_REQUEST_CODE);
Sunny Goyal2100c782016-08-22 16:00:03 -07001147
1148 mPendingActivityResult = savedState.getParcelable(RUNTIME_STATE_PENDING_ACTIVITY_RESULT);
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001149
1150 SparseArray<Parcelable> widgetsState =
1151 savedState.getSparseParcelableArray(RUNTIME_STATE_WIDGET_PANEL);
1152 if (widgetsState != null) {
1153 WidgetsFullSheet.show(this, false).restoreHierarchyState(widgetsState);
1154 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001155 }
1156
1157 /**
1158 * Finds all the views we need and configure them properly.
1159 */
Tony Wickham04fca162020-02-05 15:06:52 -08001160 protected void setupViews() {
Sunny Goyalcc96aa12018-01-11 09:56:07 -08001161 mDragLayer = findViewById(R.id.drag_layer);
Sunny Goyal3333b0c2016-05-09 20:43:21 -07001162 mFocusHandler = mDragLayer.getFocusIndicatorHelper();
Sunny Goyal966d9012017-06-06 16:43:59 -07001163 mWorkspace = mDragLayer.findViewById(R.id.workspace);
Sunny Goyald0a6ae72016-06-16 12:29:03 -07001164 mWorkspace.initParentViews(mDragLayer);
Sreyas321bfae2020-02-21 17:53:02 -08001165 mOverviewPanel = findViewById(R.id.overview_panel);
Sunny Goyal7c7be8c2018-03-07 19:58:07 -08001166 mHotseat = findViewById(R.id.hotseat);
Adam Cohenb66675a2020-05-15 16:16:17 -07001167 mHotseat.setWorkspace(mWorkspace);
Craig Mautner360310b2012-10-26 15:13:08 -07001168
Winson Chung4c98d922011-05-31 16:50:48 -07001169 // Setup the drag layer
Sunny Goyal5d1873a2018-05-08 11:10:44 -07001170 mDragLayer.setup(mDragController, mWorkspace);
Winson Chung4c98d922011-05-31 16:50:48 -07001171
Hyunyoung Song645764e2016-06-06 14:19:02 -07001172 mWorkspace.setup(mDragController);
Winsonc7d2e832016-07-28 12:24:55 -07001173 // Until the workspace is bound, ensure that we keep the wallpaper offset locked to the
1174 // default state, otherwise we will update to the wrong offsets in RTL
1175 mWorkspace.lockWallpaperToDefaultPage();
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07001176 mWorkspace.bindAndInitFirstWorkspaceScreen(null /* recycled qsb */);
Hyunyoung Song645764e2016-06-06 14:19:02 -07001177 mDragController.addDragListener(mWorkspace);
Winson Chung4c98d922011-05-31 16:50:48 -07001178
Tony Wickham34d2c912015-09-11 09:27:58 -07001179 // Get the search/delete/uninstall bar
Rajeev Kumar43c0f582017-06-23 15:34:55 -07001180 mDropTargetBar = mDragLayer.findViewById(R.id.drop_target_bar);
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07001181
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001182 // Setup Apps
1183 mAppsView = findViewById(R.id.apps_view);
Craig Mautner360310b2012-10-26 15:13:08 -07001184
Govinda Wassermanc06e1512019-04-09 09:56:53 -04001185 // Setup Scrim
1186 mScrimView = findViewById(R.id.scrim_view);
1187
Winson Chung3d503fb2011-07-13 17:25:49 -07001188 // Setup the drag controller (drop targets have to be added in reverse order in priority)
Sunny Goyal47328fd2016-05-25 18:56:41 -07001189 mDropTargetBar.setup(mDragController);
Daniel Sandler924b9932013-06-12 00:38:25 -04001190
Tony Wickham490a8ab2020-04-01 17:03:58 -07001191 mAllAppsController.setupViews(mAppsView, mScrimView);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001192 }
1193
1194 /**
1195 * Creates a view representing a shortcut.
1196 *
1197 * @param info The data structure describing the shortcut.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001198 */
Sunny Goyal95899162019-03-27 16:03:06 -07001199 View createShortcut(WorkspaceItemInfo info) {
Sunny Goyaldfaccf62015-05-11 16:30:44 -07001200 return createShortcut((ViewGroup) mWorkspace.getChildAt(mWorkspace.getCurrentPage()), info);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001201 }
1202
1203 /**
1204 * Creates a view representing a shortcut inflated from the specified resource.
1205 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001206 * @param parent The group the shortcut belongs to.
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001207 * @param info The data structure describing the shortcut.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001208 * @return A View inflated from layoutResId.
1209 */
Sunny Goyal95899162019-03-27 16:03:06 -07001210 public View createShortcut(ViewGroup parent, WorkspaceItemInfo info) {
Sunny Goyal9b29ca52017-02-17 10:39:44 -08001211 BubbleTextView favorite = (BubbleTextView) LayoutInflater.from(parent.getContext())
1212 .inflate(R.layout.app_icon, parent, false);
Sunny Goyal95899162019-03-27 16:03:06 -07001213 favorite.applyFromWorkspaceItem(info);
Sunny Goyal8a2a63b2018-03-06 22:15:18 -08001214 favorite.setOnClickListener(ItemClickHandler.INSTANCE);
Sunny Goyaldcbcc862014-08-12 15:58:36 -07001215 favorite.setOnFocusChangeListener(mFocusHandler);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001216 return favorite;
1217 }
1218
1219 /**
Jon Mirandac476d6e2017-05-04 16:30:01 -07001220 * Add a shortcut to the workspace or to a Folder.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001221 *
1222 * @param data The intent describing the shortcut.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001223 */
Sunny Goyalefb7e842018-10-04 15:11:00 -07001224 private void completeAddShortcut(Intent data, int container, int screenId, int cellX,
Sunny Goyalfb5096d2016-09-08 14:32:06 -07001225 int cellY, PendingRequestArgs args) {
Pinyao Ting5eee5f42019-10-31 16:47:35 -07001226 if (args.getRequestCode() != REQUEST_CREATE_SHORTCUT
Jon Mirandac476d6e2017-05-04 16:30:01 -07001227 || args.getPendingIntent().getComponent() == null) {
Sunny Goyalfb5096d2016-09-08 14:32:06 -07001228 return;
1229 }
Adam Cohen558baaf2011-08-15 15:22:57 -07001230
Jon Mirandac476d6e2017-05-04 16:30:01 -07001231 int[] cellXY = mTmpAddItemCellCoordinates;
1232 CellLayout layout = getCellLayout(container, screenId);
1233
Sunny Goyaleaf7a952020-07-29 16:54:20 -07001234 WorkspaceItemInfo info = PinRequestHelper.createWorkspaceItemFromPinItemRequest(
Sunny Goyale7b00122019-10-02 16:13:34 -07001235 this, PinRequestHelper.getPinItemRequest(data), 0);
Sunny Goyal782f0c92017-01-19 10:27:54 -08001236
1237 if (info == null) {
Sunny Goyalb57645f2017-03-20 13:57:28 -07001238 // Legacy shortcuts are only supported for primary profile.
1239 info = Process.myUserHandle().equals(args.user)
Sunny Goyal53116c62020-08-07 16:32:18 -07001240 ? ModelUtils.fromLegacyShortcutIntent(this, data) : null;
Sunny Goyal782f0c92017-01-19 10:27:54 -08001241
Sunny Goyalb57645f2017-03-20 13:57:28 -07001242 if (info == null) {
1243 Log.e(TAG, "Unable to parse a valid custom shortcut result");
1244 return;
1245 } else if (!new PackageManagerHelper(this).hasPermissionForActivity(
Sunny Goyal342e4662017-02-02 15:21:08 -08001246 info.intent, args.getPendingIntent().getComponent().getPackageName())) {
Sunny Goyal782f0c92017-01-19 10:27:54 -08001247 // The app is trying to add a shortcut without sufficient permissions
1248 Log.e(TAG, "Ignoring malicious intent " + info.intent.toUri(0));
1249 return;
1250 }
1251 }
1252
Jon Mirandac476d6e2017-05-04 16:30:01 -07001253 if (container < 0) {
1254 // Adding a shortcut to the Workspace.
1255 final View view = createShortcut(info);
1256 boolean foundCellSpan = false;
1257 // First we check if we already know the exact location where we want to add this item.
1258 if (cellX >= 0 && cellY >= 0) {
1259 cellXY[0] = cellX;
1260 cellXY[1] = cellY;
1261 foundCellSpan = true;
Adam Cohen558baaf2011-08-15 15:22:57 -07001262
Hyunyoung Song1ae42422020-01-26 23:25:14 -08001263 DragObject dragObject = new DragObject(getApplicationContext());
1264 dragObject.dragInfo = info;
Jon Mirandac476d6e2017-05-04 16:30:01 -07001265 // If appropriate, either create a folder or add to an existing folder
1266 if (mWorkspace.createUserFolderIfNecessary(view, container, layout, cellXY, 0,
Hyunyoung Song1ae42422020-01-26 23:25:14 -08001267 true, dragObject)) {
Jon Mirandac476d6e2017-05-04 16:30:01 -07001268 return;
1269 }
Jon Mirandac476d6e2017-05-04 16:30:01 -07001270 if (mWorkspace.addToExistingFolderIfNecessary(view, layout, cellXY, 0, dragObject,
1271 true)) {
1272 return;
1273 }
1274 } else {
1275 foundCellSpan = layout.findCellForSpan(cellXY, 1, 1);
1276 }
1277
1278 if (!foundCellSpan) {
1279 mWorkspace.onNoCellFound(layout);
Adam Cohen558baaf2011-08-15 15:22:57 -07001280 return;
1281 }
Jon Mirandac476d6e2017-05-04 16:30:01 -07001282
1283 getModelWriter().addItemToDatabase(info, container, screenId, cellXY[0], cellXY[1]);
1284 mWorkspace.addInScreen(view, info);
Michael Jurkad3ef3062010-11-23 16:23:58 -08001285 } else {
Jon Mirandac476d6e2017-05-04 16:30:01 -07001286 // Adding a shortcut to a Folder.
Sunny Goyale29897f52017-07-20 10:09:42 -07001287 FolderIcon folderIcon = findFolderIcon(container);
Jon Mirandac476d6e2017-05-04 16:30:01 -07001288 if (folderIcon != null) {
1289 FolderInfo folderInfo = (FolderInfo) folderIcon.getTag();
1290 folderInfo.add(info, args.rank, false);
1291 } else {
Sunny Goyale29897f52017-07-20 10:09:42 -07001292 Log.e(TAG, "Could not find folder with id " + container + " to add shortcut.");
Jon Mirandac476d6e2017-05-04 16:30:01 -07001293 }
Michael Jurka0280c3b2010-09-17 15:00:07 -07001294 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001295 }
1296
Sunny Goyalefb7e842018-10-04 15:11:00 -07001297 public FolderIcon findFolderIcon(final int folderIconId) {
Sunny Goyal83fd25e2018-07-09 16:47:01 -07001298 return (FolderIcon) mWorkspace.getHomescreenIconByItemId(folderIconId);
Sunny Goyale29897f52017-07-20 10:09:42 -07001299 }
1300
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001301 /**
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001302 * Add a widget to the workspace.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001303 *
Romain Guy5bbc91b2010-08-18 11:38:46 -07001304 * @param appWidgetId The app widget id
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001305 */
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001306 @Thunk
1307 void completeAddAppWidget(int appWidgetId, ItemInfo itemInfo,
Adam Cohen59400422014-03-05 18:07:04 -08001308 AppWidgetHostView hostView, LauncherAppWidgetProviderInfo appWidgetInfo) {
1309
Adam Cohened66b2b2012-01-23 17:28:51 -08001310 if (appWidgetInfo == null) {
Sunny Goyal2e1efb42016-03-03 16:58:55 -08001311 appWidgetInfo = mAppWidgetManager.getLauncherAppWidgetInfo(appWidgetId);
Adam Cohened66b2b2012-01-23 17:28:51 -08001312 }
Romain Guycbb89e42009-06-08 15:52:54 -07001313
Adam Cohen59400422014-03-05 18:07:04 -08001314 LauncherAppWidgetInfo launcherInfo;
1315 launcherInfo = new LauncherAppWidgetInfo(appWidgetId, appWidgetInfo.provider);
Sunny Goyal2100c782016-08-22 16:00:03 -07001316 launcherInfo.spanX = itemInfo.spanX;
1317 launcherInfo.spanY = itemInfo.spanY;
1318 launcherInfo.minSpanX = itemInfo.minSpanX;
1319 launcherInfo.minSpanY = itemInfo.minSpanY;
Sunny Goyal952e63d2017-08-16 04:59:08 -07001320 launcherInfo.user = appWidgetInfo.getProfile();
Romain Guycbb89e42009-06-08 15:52:54 -07001321
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001322 getModelWriter().addItemToDatabase(launcherInfo,
Sunny Goyal2100c782016-08-22 16:00:03 -07001323 itemInfo.container, itemInfo.screenId, itemInfo.cellX, itemInfo.cellY);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001324
Sunny Goyal2100c782016-08-22 16:00:03 -07001325 if (hostView == null) {
1326 // Perform actual inflation because we're live
1327 hostView = mAppWidgetHost.createView(this, appWidgetId, appWidgetInfo);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001328 }
Sunny Goyal2100c782016-08-22 16:00:03 -07001329 hostView.setVisibility(View.VISIBLE);
Sunny Goyald5462aa2016-11-22 16:52:39 +05301330 prepareAppWidget(hostView, launcherInfo);
1331 mWorkspace.addInScreen(hostView, launcherInfo);
Pinyao Tingc9074272019-11-11 11:51:44 -08001332 announceForAccessibility(R.string.item_added_to_workspace);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001333 }
Romain Guycbb89e42009-06-08 15:52:54 -07001334
Sunny Goyald5462aa2016-11-22 16:52:39 +05301335 private void prepareAppWidget(AppWidgetHostView hostView, LauncherAppWidgetInfo item) {
Sunny Goyal87af0fd2016-05-16 14:56:02 -07001336 hostView.setTag(item);
1337 item.onBindAppWidget(this, hostView);
Sunny Goyal87af0fd2016-05-16 14:56:02 -07001338 hostView.setFocusable(true);
1339 hostView.setOnFocusChangeListener(mFocusHandler);
Sunny Goyal25c2e3e2015-10-28 23:28:21 -07001340 }
1341
Sunny Goyal5d1873a2018-05-08 11:10:44 -07001342 private final BroadcastReceiver mScreenOffReceiver = new BroadcastReceiver() {
Adam Cohended9f8d2010-11-03 13:25:16 -07001343 @Override
1344 public void onReceive(Context context, Intent intent) {
Sunny Goyal5d1873a2018-05-08 11:10:44 -07001345 // Reset AllApps to its initial state only if we are not in the middle of
1346 // processing a multi-step drop
1347 if (mPendingRequestArgs == null) {
Riddle Hsu7a7468f2019-11-21 01:32:58 +08001348 if (!isInState(NORMAL)) {
1349 onUiChangedWhileSleeping();
1350 }
Sunny Goyal5d1873a2018-05-08 11:10:44 -07001351 mStateManager.goToState(NORMAL);
Adam Cohended9f8d2010-11-03 13:25:16 -07001352 }
1353 }
1354 };
1355
Sunny Goyal9c2b9602020-01-07 13:07:55 -08001356 private void updateNotificationDots(Predicate<PackageUserKey> updatedDots) {
Tony Wickhamf34bee82018-12-03 18:11:39 -08001357 mWorkspace.updateNotificationDots(updatedDots);
1358 mAppsView.getAppsStore().updateNotificationDots(updatedDots);
Tony Wickham010d2552017-01-20 08:15:28 -08001359 }
1360
Adam Cohended9f8d2010-11-03 13:25:16 -07001361 @Override
1362 public void onAttachedToWindow() {
1363 super.onAttachedToWindow();
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001364 mOverlayManager.onAttachedToWindow();
Adam Cohended9f8d2010-11-03 13:25:16 -07001365 }
1366
1367 @Override
1368 public void onDetachedFromWindow() {
1369 super.onDetachedFromWindow();
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001370 mOverlayManager.onDetachedFromWindow();
1371 closeContextMenu();
Adam Cohended9f8d2010-11-03 13:25:16 -07001372 }
1373
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -07001374 @Override
1375 public Object onRetainNonConfigurationInstance() {
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08001376 NonConfigInstance instance = new NonConfigInstance();
1377 instance.config = new Configuration(mOldConfig);
1378
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -07001379 int width = mDragLayer.getWidth();
1380 int height = mDragLayer.getHeight();
1381
Schneider Victor-tulias5aad9d82020-12-15 10:47:44 -05001382 if (FeatureFlags.ENABLE_LAUNCHER_ACTIVITY_THEME_CROSSFADE.get()
1383 && width > 0
1384 && height > 0) {
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08001385 instance.snapshot =
1386 BitmapRenderer.createHardwareBitmap(width, height, mDragLayer::draw);
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -07001387 }
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08001388 return instance;
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -07001389 }
1390
Sunny Goyalc4fa8c32017-11-07 12:23:58 -08001391 public AllAppsTransitionController getAllAppsController() {
1392 return mAllAppsController;
1393 }
1394
Sunny Goyal9d69c8d2018-03-19 13:41:31 -07001395 @Override
Winson Chunga6945242014-01-08 14:04:34 -08001396 public DragLayer getDragLayer() {
1397 return mDragLayer;
1398 }
1399
Winson Chung5f4e0fd2015-05-22 11:12:27 -07001400 public AllAppsContainerView getAppsView() {
Winson Chungb745afb2015-03-02 11:51:23 -08001401 return mAppsView;
1402 }
1403
Winson Chunga6945242014-01-08 14:04:34 -08001404 public Workspace getWorkspace() {
1405 return mWorkspace;
1406 }
1407
1408 public Hotseat getHotseat() {
1409 return mHotseat;
1410 }
1411
Sunny Goyal7c7be8c2018-03-07 19:58:07 -08001412 public <T extends View> T getOverviewPanel() {
Winson Chung8ae41982017-11-10 11:42:13 -08001413 return (T) mOverviewPanel;
Winson Chunga6945242014-01-08 14:04:34 -08001414 }
1415
Sunny Goyal47328fd2016-05-25 18:56:41 -07001416 public DropTargetBar getDropTargetBar() {
1417 return mDropTargetBar;
Tony Wickham34d2c912015-09-11 09:27:58 -07001418 }
1419
Tony Wickham490a8ab2020-04-01 17:03:58 -07001420 public ScrimView getScrimView() {
1421 return mScrimView;
1422 }
1423
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001424 public LauncherAppWidgetHost getAppWidgetHost() {
1425 return mAppWidgetHost;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001426 }
Romain Guycbb89e42009-06-08 15:52:54 -07001427
Winson Chunga9abd0e2010-10-27 17:18:37 -07001428 public LauncherModel getModel() {
1429 return mModel;
1430 }
1431
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001432 public ModelWriter getModelWriter() {
1433 return mModelWriter;
1434 }
1435
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001436 @Override
Adam Cohen79d90c52016-04-22 13:29:20 -07001437 public SharedPreferences getSharedPrefs() {
Winson Chunga6945242014-01-08 14:04:34 -08001438 return mSharedPrefs;
1439 }
1440
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001441 @Override
1442 public SharedPreferences getDevicePrefs() {
1443 return Utilities.getDevicePrefs(this);
1444 }
1445
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001446 public int getOrientation() {
1447 return mOldConfig.orientation;
1448 }
Jon Miranda6bed3502017-09-19 14:43:17 -07001449
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001450 @Override
1451 protected void onNewIntent(Intent intent) {
vadimtbaf5fbb2019-12-16 18:56:09 -08001452 if (Utilities.IS_RUNNING_IN_TEST_HARNESS) {
1453 Log.d(TestProtocol.PERMANENT_DIAG_TAG, "Launcher.onNewIntent: " + intent);
1454 }
Winson Chung5cc62c72019-10-16 11:32:41 -07001455 Object traceToken = TraceHelper.INSTANCE.beginSection(ON_NEW_INTENT_EVT);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001456 super.onNewIntent(intent);
1457
Sunny Goyalf4aceab2017-12-06 16:16:31 -08001458 boolean alreadyOnHome = hasWindowFocus() && ((intent.getFlags() &
Winson15f8b172015-08-19 11:02:39 -07001459 Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT)
1460 != Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT);
Sunny Goyal85313732016-09-28 12:00:07 -07001461
1462 // Check this condition before handling isActionMain, as this will get reset.
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001463 boolean shouldMoveToDefaultScreen = alreadyOnHome && isInState(NORMAL)
Sunny Goyalf9403d92017-10-18 10:55:56 -07001464 && AbstractFloatingView.getTopOpenView(this) == null;
Winson15f8b172015-08-19 11:02:39 -07001465 boolean isActionMain = Intent.ACTION_MAIN.equals(intent.getAction());
Sunny Goyale84c5b82019-09-26 17:05:31 -07001466 boolean internalStateHandled = ACTIVITY_TRACKER.handleNewIntent(this, intent);
Sunny Goyald3864fa2017-11-14 15:06:36 -08001467
Winson15f8b172015-08-19 11:02:39 -07001468 if (isActionMain) {
Sunny Goyald3864fa2017-11-14 15:06:36 -08001469 if (!internalStateHandled) {
Sunny Goyald3864fa2017-11-14 15:06:36 -08001470 // In all these cases, only animate if we're already on home
Andy Wickham65ced1b2020-03-07 02:14:19 +00001471 closeOpenViews(isStarted());
Jon Mirandafeba90f2016-10-06 10:53:29 -07001472
Sunny Goyala2467272018-03-16 14:53:05 -07001473 if (!isInState(NORMAL)) {
1474 // Only change state, if not already the same. This prevents cancelling any
1475 // animations running as part of resume
Sunny Goyalfee1b252020-12-14 12:30:38 -08001476 mStateManager.goToState(NORMAL, mStateManager.shouldAnimateStateChange());
Sunny Goyala2467272018-03-16 14:53:05 -07001477 }
Sunny Goyald3864fa2017-11-14 15:06:36 -08001478
1479 // Reset the apps view
Sunny Goyal5d1873a2018-05-08 11:10:44 -07001480 if (!alreadyOnHome) {
Sunny Goyal7185dd62018-03-14 17:51:49 -07001481 mAppsView.reset(isStarted() /* animate */);
Sunny Goyald3864fa2017-11-14 15:06:36 -08001482 }
1483
Sunny Goyalaad33592018-08-07 17:20:35 -07001484 if (shouldMoveToDefaultScreen && !mWorkspace.isHandlingTouch()) {
Sunny Goyald3864fa2017-11-14 15:06:36 -08001485 mWorkspace.post(mWorkspace::moveToDefaultScreen);
1486 }
1487 }
Adam Cohen6fecd412013-10-02 17:41:50 -07001488
Hyunyoung Song2a70b3d2019-06-11 12:47:07 -07001489 // Handle HOME_INTENT
Sunny Goyaldeb91c42020-03-24 02:17:59 -07001490 hideKeyboard();
Adam Cohen6fecd412013-10-02 17:41:50 -07001491
Adam Cohen9211d422014-10-07 18:14:53 -07001492 if (mLauncherCallbacks != null) {
Sunny Goyal85462132018-04-24 11:39:37 -07001493 mLauncherCallbacks.onHomeIntent(internalStateHandled);
Adam Cohen9211d422014-10-07 18:14:53 -07001494 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001495 mOverlayManager.hideOverlay(isStarted() && !isForceInvisible());
Sunny Goyal30ac97d2020-06-24 23:47:46 -07001496 handleGestureContract(intent);
Sunny Goyal512a2c12020-04-08 12:52:45 -07001497 } else if (Intent.ACTION_ALL_APPS.equals(intent.getAction())) {
Winson Chungdd15ace2020-08-04 15:52:01 -07001498 showAllAppsFromIntent(alreadyOnHome);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001499 }
Winson15f8b172015-08-19 11:02:39 -07001500
Winson Chung5cc62c72019-10-16 11:32:41 -07001501 TraceHelper.INSTANCE.endSection(traceToken);
Adam Coppa120b8e2013-11-12 16:26:04 +00001502 }
1503
Winson Chungdd15ace2020-08-04 15:52:01 -07001504 protected void showAllAppsFromIntent(boolean alreadyOnHome) {
1505 AbstractFloatingView.closeAllOpenViews(this);
1506 getStateManager().goToState(ALL_APPS, alreadyOnHome);
1507 }
1508
Sunny Goyaldeb91c42020-03-24 02:17:59 -07001509 /**
Sunny Goyal30ac97d2020-06-24 23:47:46 -07001510 * Handles gesture nav contract
1511 */
1512 protected void handleGestureContract(Intent intent) {
1513 GestureNavContract gnc = GestureNavContract.fromIntent(intent);
1514 if (gnc != null) {
1515 AbstractFloatingView.closeOpenViews(this, false, TYPE_ICON_SURFACE);
1516 FloatingSurfaceView.show(this, gnc);
1517 }
1518 }
1519
1520 /**
Sunny Goyaldeb91c42020-03-24 02:17:59 -07001521 * Hides the keyboard if visible
1522 */
1523 public void hideKeyboard() {
1524 final View v = getWindow().peekDecorView();
1525 if (v != null && v.getWindowToken() != null) {
1526 UiThreadHelper.hideKeyboardAsync(this, v.getWindowToken());
1527 }
1528 }
1529
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001530 @Override
Adam Cohen1462de32012-07-24 22:34:36 -07001531 public void onRestoreInstanceState(Bundle state) {
1532 super.onRestoreInstanceState(state);
Sunny Goyalf4aceab2017-12-06 16:16:31 -08001533 mWorkspace.restoreInstanceStateForChild(mSynchronouslyBoundPage);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001534 }
1535
1536 @Override
1537 protected void onSaveInstanceState(Bundle outState) {
Adam Cohen21cd0022013-10-09 18:57:02 -07001538 if (mWorkspace.getChildCount() > 0) {
Sunny Goyal7ce471b2017-08-02 03:37:39 -07001539 outState.putInt(RUNTIME_STATE_CURRENT_SCREEN, mWorkspace.getNextPage());
Hyunyoung Song645764e2016-06-06 14:19:02 -07001540
Adam Cohen21cd0022013-10-09 18:57:02 -07001541 }
Sunny Goyalea609262017-10-25 15:47:38 -07001542 outState.putInt(RUNTIME_STATE, mStateManager.getState().ordinal);
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001543
1544
1545 AbstractFloatingView widgets = AbstractFloatingView
1546 .getOpenView(this, AbstractFloatingView.TYPE_WIDGETS_FULL_SHEET);
1547 if (widgets != null) {
1548 SparseArray<Parcelable> widgetsState = new SparseArray<>();
1549 widgets.saveHierarchyState(widgetsState);
1550 outState.putSparseParcelableArray(RUNTIME_STATE_WIDGET_PANEL, widgetsState);
1551 } else {
1552 outState.remove(RUNTIME_STATE_WIDGET_PANEL);
1553 }
1554
Pinyao Tinga74b63a2019-07-17 23:26:06 -07001555 // We close any open folders and shortcut containers that are not safe for rebind,
Sunny Goyal740ac7f2016-09-28 16:47:32 -07001556 // and we need to make sure this state is reflected.
Pinyao Tinga74b63a2019-07-17 23:26:06 -07001557 AbstractFloatingView.closeOpenViews(this, false, TYPE_ALL & ~TYPE_REBIND_SAFE);
1558 finishAutoCancelActionMode();
Tony Wickham49c8d292016-07-01 11:44:34 -07001559
Sunny Goyal2100c782016-08-22 16:00:03 -07001560 if (mPendingRequestArgs != null) {
1561 outState.putParcelable(RUNTIME_STATE_PENDING_REQUEST_ARGS, mPendingRequestArgs);
1562 }
Sunny Goyaldedda052019-05-14 15:23:48 -07001563 outState.putInt(RUNTIME_STATE_PENDING_REQUEST_CODE, mPendingActivityRequestCode);
1564
Sunny Goyal2100c782016-08-22 16:00:03 -07001565 if (mPendingActivityResult != null) {
1566 outState.putParcelable(RUNTIME_STATE_PENDING_ACTIVITY_RESULT, mPendingActivityResult);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001567 }
1568
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001569 super.onSaveInstanceState(outState);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001570 mOverlayManager.onActivitySaveInstanceState(this, outState);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001571 }
1572
1573 @Override
1574 public void onDestroy() {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001575 super.onDestroy();
Sunny Goyale84c5b82019-09-26 17:05:31 -07001576 ACTIVITY_TRACKER.onActivityDestroyed(this);
Romain Guycbb89e42009-06-08 15:52:54 -07001577
Sunny Goyal5d1873a2018-05-08 11:10:44 -07001578 unregisterReceiver(mScreenOffReceiver);
Sunny Goyalaaf7d1d2016-05-17 13:38:54 -07001579 mWorkspace.removeFolderListeners();
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001580 PluginManagerWrapper.INSTANCE.get(this).removePluginListener(this);
Winson Chunge7a03942011-08-05 15:05:12 -07001581
Sunny Goyala7a5bf32020-01-05 15:35:29 +05301582 mModel.removeCallbacks(this);
Sunny Goyal623eddd2018-03-02 12:24:41 -08001583 mRotationHelper.destroy();
Sunny Goyal745bad92016-05-02 10:54:12 -07001584
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001585 try {
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001586 mAppWidgetHost.stopListening();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001587 } catch (NullPointerException ex) {
Joe Onoratoa30ce8e2009-11-11 08:16:49 -08001588 Log.w(TAG, "problem while stopping AppWidgetHost during Launcher destruction", ex);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001589 }
Patrick Dubroy2313eff2011-01-11 20:01:31 -08001590
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001591 TextKeyListener.getInstance().release();
Tony2917a8b2017-07-31 23:29:42 -07001592 clearPendingBinds();
Hyunyoung Song31971a32019-01-27 12:31:12 -08001593 LauncherAppState.getIDP(this).removeOnChangeListener(this);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001594
1595 mOverlayManager.onActivityDestroyed(this);
Samuel Fufa41d909f2020-03-20 16:27:09 -07001596 mUserChangedCallbackCloseable.close();
Samuel Fufa37432442020-11-01 13:06:43 -08001597 mLiveSearchManager.stop();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001598 }
1599
Sunny Goyalae502842016-06-17 08:43:56 -07001600 public LauncherAccessibilityDelegate getAccessibilityDelegate() {
1601 return mAccessibilityDelegate;
1602 }
1603
Adam Cohena9cf38f2011-05-02 15:36:58 -07001604 public DragController getDragController() {
1605 return mDragController;
1606 }
1607
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001608 @Override
Sunny Goyal0eca4e22016-07-20 11:43:06 -07001609 public void startActivityForResult(Intent intent, int requestCode, Bundle options) {
Sunny Goyaldedda052019-05-14 15:23:48 -07001610 if (requestCode != -1) {
1611 mPendingActivityRequestCode = requestCode;
1612 }
Sunny Goyal210e1742019-10-17 12:05:38 -07001613 super.startActivityForResult(intent, requestCode, options);
Adam Cohen173f7112015-03-27 15:14:00 -07001614 }
1615
1616 @Override
Sunny Goyaldedda052019-05-14 15:23:48 -07001617 public void startIntentSenderForResult(IntentSender intent, int requestCode,
Adam Cohen173f7112015-03-27 15:14:00 -07001618 Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags, Bundle options) {
Sunny Goyaldedda052019-05-14 15:23:48 -07001619 if (requestCode != -1) {
1620 mPendingActivityRequestCode = requestCode;
1621 }
Sunny Goyal210e1742019-10-17 12:05:38 -07001622 try {
1623 super.startIntentSenderForResult(intent, requestCode,
1624 fillInIntent, flagsMask, flagsValues, extraFlags, options);
1625 } catch (IntentSender.SendIntentException e) {
1626 throw new ActivityNotFoundException();
Adam Cohen173f7112015-03-27 15:14:00 -07001627 }
1628 }
1629
Winson Chung70d72102011-08-12 11:24:35 -07001630 /**
1631 * Indicates that we want global search for this activity by setting the globalSearch
1632 * argument for {@link #startSearch} to true.
1633 */
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001634 @Override
Romain Guycbb89e42009-06-08 15:52:54 -07001635 public void startSearch(String initialQuery, boolean selectInitialQuery,
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001636 Bundle appSearchData, boolean globalSearch) {
1637 if (appSearchData == null) {
1638 appSearchData = new Bundle();
Bjorn Bringert32b12d22013-06-06 13:00:41 +01001639 appSearchData.putString("source", "launcher-search");
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001640 }
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07001641
Sunny Goyal6f28e712016-09-13 14:19:29 -07001642 if (mLauncherCallbacks == null ||
1643 !mLauncherCallbacks.startSearch(initialQuery, selectInitialQuery, appSearchData)) {
1644 // Starting search from the callbacks failed. Start the default global search.
Sunny Goyalf4aceab2017-12-06 16:16:31 -08001645 super.startSearch(initialQuery, selectInitialQuery, appSearchData, true);
Ian Parkinson047036e2014-09-01 15:40:53 +01001646 }
Winson Chungcd99cd32015-04-29 11:03:24 -07001647
1648 // We need to show the workspace after starting the search
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001649 mStateManager.goToState(NORMAL);
Bjorn Bringertc459e522013-06-07 19:36:01 +01001650 }
1651
Joe Onorato9c1289c2009-08-17 11:03:03 -04001652 public boolean isWorkspaceLocked() {
Sunny Goyal2100c782016-08-22 16:00:03 -07001653 return mWorkspaceLoading || mPendingRequestArgs != null;
Joe Onorato9c1289c2009-08-17 11:03:03 -04001654 }
1655
Adam Cohen517a7f52014-03-01 12:12:59 -08001656 public boolean isWorkspaceLoading() {
1657 return mWorkspaceLoading;
1658 }
1659
Anjali Koppalff7ceff2014-05-01 18:26:37 -07001660 private void setWorkspaceLoading(boolean value) {
Anjali Koppalff7ceff2014-05-01 18:26:37 -07001661 mWorkspaceLoading = value;
Anjali Koppalff7ceff2014-05-01 18:26:37 -07001662 }
1663
Sunny Goyal04a324a2017-01-20 21:08:59 -08001664 public void setWaitingForResult(PendingRequestArgs args) {
Sunny Goyal2100c782016-08-22 16:00:03 -07001665 mPendingRequestArgs = args;
Adam Cohen9211d422014-10-07 18:14:53 -07001666 }
Anjali Koppalff7ceff2014-05-01 18:26:37 -07001667
Sunny Goyal2100c782016-08-22 16:00:03 -07001668 void addAppWidgetFromDropImpl(int appWidgetId, ItemInfo info, AppWidgetHostView boundWidget,
Sunny Goyal04a324a2017-01-20 21:08:59 -08001669 WidgetAddFlowHandler addFlowHandler) {
Tony Wickhama0628cc2015-10-14 15:23:04 -07001670 if (LOGD) {
1671 Log.d(TAG, "Adding widget from drop");
1672 }
Sunny Goyal04a324a2017-01-20 21:08:59 -08001673 addAppWidgetImpl(appWidgetId, info, boundWidget, addFlowHandler, 0);
Adam Cohenad4e15c2013-10-17 16:21:35 -07001674 }
1675
Sunny Goyal2100c782016-08-22 16:00:03 -07001676 void addAppWidgetImpl(int appWidgetId, ItemInfo info,
Sunny Goyal04a324a2017-01-20 21:08:59 -08001677 AppWidgetHostView boundWidget, WidgetAddFlowHandler addFlowHandler, int delay) {
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001678 if (!addFlowHandler.startConfigActivity(this, appWidgetId, info,
1679 REQUEST_CREATE_APPWIDGET)) {
Sunny Goyal04a324a2017-01-20 21:08:59 -08001680 // If the configuration flow was not started, add the widget
Michael Jurkaaf442092010-06-10 17:01:57 -07001681
Adam Cohenad4e15c2013-10-17 16:21:35 -07001682 Runnable onComplete = new Runnable() {
1683 @Override
1684 public void run() {
1685 // Exit spring loaded mode if necessary after adding the widget
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001686 mStateManager.goToState(NORMAL, SPRING_LOADED_EXIT_DELAY);
Adam Cohenad4e15c2013-10-17 16:21:35 -07001687 }
1688 };
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001689 completeAddAppWidget(appWidgetId, info, boundWidget,
1690 addFlowHandler.getProviderInfo(this));
Sunny Goyal6e379fc2020-03-19 16:08:14 -07001691 mWorkspace.removeExtraEmptyScreenDelayed(delay, false, onComplete);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001692 }
1693 }
Romain Guycbb89e42009-06-08 15:52:54 -07001694
Sunny Goyalefb7e842018-10-04 15:11:00 -07001695 public void addPendingItem(PendingAddItemInfo info, int container, int screenId,
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08001696 int[] cell, int spanX, int spanY) {
Sunny Goyal2100c782016-08-22 16:00:03 -07001697 info.container = container;
1698 info.screenId = screenId;
1699 if (cell != null) {
1700 info.cellX = cell[0];
1701 info.cellY = cell[1];
1702 }
1703 info.spanX = spanX;
1704 info.spanY = spanY;
1705
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08001706 switch (info.itemType) {
1707 case LauncherSettings.Favorites.ITEM_TYPE_CUSTOM_APPWIDGET:
1708 case LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET:
Sunny Goyal2100c782016-08-22 16:00:03 -07001709 addAppWidgetFromDrop((PendingAddWidgetInfo) info);
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08001710 break;
1711 case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT:
Sunny Goyal782f0c92017-01-19 10:27:54 -08001712 processShortcutFromDrop((PendingAddShortcutInfo) info);
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08001713 break;
1714 default:
1715 throw new IllegalStateException("Unknown item type: " + info.itemType);
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001716 }
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08001717 }
1718
Adam Cohenfbba09b2011-07-18 21:43:05 -07001719 /**
1720 * Process a shortcut drop.
Adam Cohenfbba09b2011-07-18 21:43:05 -07001721 */
Sunny Goyal782f0c92017-01-19 10:27:54 -08001722 private void processShortcutFromDrop(PendingAddShortcutInfo info) {
Sunny Goyalfb5096d2016-09-08 14:32:06 -07001723 Intent intent = new Intent(Intent.ACTION_CREATE_SHORTCUT).setComponent(info.componentName);
1724 setWaitingForResult(PendingRequestArgs.forIntent(REQUEST_CREATE_SHORTCUT, intent, info));
vadimtcf275c12020-04-15 12:43:01 -07001725 TestLogging.recordEvent(TestProtocol.SEQUENCE_MAIN, "start: processShortcutFromDrop");
Sunny Goyal782f0c92017-01-19 10:27:54 -08001726 if (!info.activityInfo.startConfigActivity(this, REQUEST_CREATE_SHORTCUT)) {
1727 handleActivityResult(REQUEST_CREATE_SHORTCUT, RESULT_CANCELED, null);
1728 }
Michael Jurka0280c3b2010-09-17 15:00:07 -07001729 }
1730
Adam Cohenfbba09b2011-07-18 21:43:05 -07001731 /**
1732 * Process a widget drop.
Adam Cohenfbba09b2011-07-18 21:43:05 -07001733 */
Sunny Goyal2100c782016-08-22 16:00:03 -07001734 private void addAppWidgetFromDrop(PendingAddWidgetInfo info) {
Adam Cohened66b2b2012-01-23 17:28:51 -08001735 AppWidgetHostView hostView = info.boundWidget;
Sunny Goyal952e63d2017-08-16 04:59:08 -07001736 final int appWidgetId;
Sunny Goyal8a0dc382017-01-25 11:30:06 -08001737 WidgetAddFlowHandler addFlowHandler = info.getHandler();
Adam Cohened66b2b2012-01-23 17:28:51 -08001738 if (hostView != null) {
Tony Wickhama0628cc2015-10-14 15:23:04 -07001739 // In the case where we've prebound the widget, we remove it from the DragLayer
1740 if (LOGD) {
1741 Log.d(TAG, "Removing widget view from drag layer and setting boundWidget to null");
1742 }
1743 getDragLayer().removeView(hostView);
1744
Adam Cohened66b2b2012-01-23 17:28:51 -08001745 appWidgetId = hostView.getAppWidgetId();
Sunny Goyal04a324a2017-01-20 21:08:59 -08001746 addAppWidgetFromDropImpl(appWidgetId, info, hostView, addFlowHandler);
Sunny Goyal5b9ebca2015-06-01 18:37:32 -07001747
1748 // Clear the boundWidget so that it doesn't get destroyed.
1749 info.boundWidget = null;
Adam Cohened66b2b2012-01-23 17:28:51 -08001750 } else {
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001751 // In this case, we either need to start an activity to get permission to bind
1752 // the widget, or we need to start an activity to configure the widget, or both.
Pinyao Tingc7a6c292019-08-26 14:36:02 -07001753 if (info.itemType == LauncherSettings.Favorites.ITEM_TYPE_CUSTOM_APPWIDGET) {
1754 appWidgetId = CustomWidgetManager.INSTANCE.get(this).getWidgetIdForCustomProvider(
1755 info.componentName);
Sunny Goyal952e63d2017-08-16 04:59:08 -07001756 } else {
1757 appWidgetId = getAppWidgetHost().allocateAppWidgetId();
1758 }
Adam Cohendd70d662012-10-04 16:53:44 -07001759 Bundle options = info.bindOptions;
1760
Sunny Goyalffe83f12014-08-14 17:39:34 -07001761 boolean success = mAppWidgetManager.bindAppWidgetIdIfAllowed(
1762 appWidgetId, info.info, options);
Adam Cohendd70d662012-10-04 16:53:44 -07001763 if (success) {
Sunny Goyal04a324a2017-01-20 21:08:59 -08001764 addAppWidgetFromDropImpl(appWidgetId, info, null, addFlowHandler);
Michael Jurka8b805b12012-04-18 14:23:14 -07001765 } else {
Sunny Goyal04a324a2017-01-20 21:08:59 -08001766 addFlowHandler.startBindFlow(this, appWidgetId, info, REQUEST_BIND_APPWIDGET);
Michael Jurka8b805b12012-04-18 14:23:14 -07001767 }
Adam Cohened66b2b2012-01-23 17:28:51 -08001768 }
Adam Cohenfbba09b2011-07-18 21:43:05 -07001769 }
1770
Samuel Fufa746d4202020-02-02 18:55:44 -08001771 /**
1772 * Creates and adds new folder to CellLayout
1773 */
Samuel Fufa28c3e452020-02-08 16:07:16 -08001774 public FolderIcon addFolder(CellLayout layout, int container, final int screenId, int cellX,
1775 int cellY) {
Michael Jurkac9d95c52011-08-29 14:03:34 -07001776 final FolderInfo folderInfo = new FolderInfo();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001777
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001778 // Update the model
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001779 getModelWriter().addItemToDatabase(folderInfo, container, screenId, cellX, cellY);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001780
1781 // Create the view
Samuel Fufa746d4202020-02-02 18:55:44 -08001782 FolderIcon newFolder = FolderIcon.inflateFolderAndIcon(R.layout.folder_icon, this, layout,
1783 folderInfo);
Sunny Goyald5462aa2016-11-22 16:52:39 +05301784 mWorkspace.addInScreen(newFolder, folderInfo);
Winson Chung5f8afe62013-08-12 16:19:28 -07001785 // Force measure the new folder icon
1786 CellLayout parent = mWorkspace.getParentCellLayoutForView(newFolder);
1787 parent.getShortcutsAndWidgets().measureChild(newFolder);
Adam Cohendf035382011-04-11 17:22:04 -07001788 return newFolder;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001789 }
Romain Guycbb89e42009-06-08 15:52:54 -07001790
Tony Wickham1906cc32021-02-11 11:55:24 -08001791 @Override
1792 public Rect getFolderBoundingBox() {
1793 // We need to bound the folder to the currently visible workspace area
1794 Rect folderBoundingBox = new Rect();
1795 getWorkspace().getPageAreaRelativeToDragLayer(folderBoundingBox);
1796 return folderBoundingBox;
1797 }
1798
1799 @Override
1800 public void updateOpenFolderPosition(int[] inOutPosition, Rect bounds, int width, int height) {
1801 int left = inOutPosition[0];
1802 int top = inOutPosition[1];
1803 DeviceProfile grid = getDeviceProfile();
1804 int distFromEdgeOfScreen = getWorkspace().getPaddingLeft();
1805 if (grid.isPhone && (grid.availableWidthPx - width) < 4 * distFromEdgeOfScreen) {
1806 // Center the folder if it is very close to being centered anyway, by virtue of
1807 // filling the majority of the viewport. ie. remove it from the uncanny valley
1808 // of centeredness.
1809 left = (grid.availableWidthPx - width) / 2;
1810 } else if (width >= bounds.width()) {
1811 // If the folder doesn't fit within the bounds, center it about the desired bounds
1812 left = bounds.left + (bounds.width() - width) / 2;
1813 }
1814 if (height >= bounds.height()) {
1815 // Folder height is greater than page height, center on page
1816 top = bounds.top + (bounds.height() - height) / 2;
1817 } else {
1818 // Folder height is less than page height, so bound it to the absolute open folder
1819 // bounds if necessary
1820 Rect folderBounds = grid.getAbsoluteOpenFolderBounds();
1821 left = Math.max(folderBounds.left, Math.min(left, folderBounds.right - width));
1822 top = Math.max(folderBounds.top, Math.min(top, folderBounds.bottom - height));
1823 }
1824 inOutPosition[0] = left;
1825 inOutPosition[1] = top;
1826 }
1827
Winsonc0b52fe2015-09-09 16:38:15 -07001828 /**
Winsonfa56b3f2015-09-14 12:01:13 -07001829 * Unbinds the view for the specified item, and removes the item and all its children.
1830 *
1831 * @param v the view being removed.
Winsonfa56b3f2015-09-14 12:01:13 -07001832 * @param itemInfo the {@link ItemInfo} for this view.
1833 * @param deleteFromDb whether or not to delete this item from the db.
Winsonc0b52fe2015-09-09 16:38:15 -07001834 */
Tony Wickhambfbf7f92016-05-19 11:19:39 -07001835 public boolean removeItem(View v, final ItemInfo itemInfo, boolean deleteFromDb) {
Sunny Goyal95899162019-03-27 16:03:06 -07001836 if (itemInfo instanceof WorkspaceItemInfo) {
Winsonfa56b3f2015-09-14 12:01:13 -07001837 // Remove the shortcut from the folder before removing it from launcher
Sunny Goyal44c06432016-04-02 10:56:02 -07001838 View folderIcon = mWorkspace.getHomescreenIconByItemId(itemInfo.container);
1839 if (folderIcon instanceof FolderIcon) {
Sunny Goyal95899162019-03-27 16:03:06 -07001840 ((FolderInfo) folderIcon.getTag()).remove((WorkspaceItemInfo) itemInfo, true);
Winsonfa56b3f2015-09-14 12:01:13 -07001841 } else {
1842 mWorkspace.removeWorkspaceItem(v);
1843 }
Winsonc0b52fe2015-09-09 16:38:15 -07001844 if (deleteFromDb) {
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001845 getModelWriter().deleteItemFromDatabase(itemInfo);
Winsonc0b52fe2015-09-09 16:38:15 -07001846 }
1847 } else if (itemInfo instanceof FolderInfo) {
1848 final FolderInfo folderInfo = (FolderInfo) itemInfo;
Sunny Goyalaaf7d1d2016-05-17 13:38:54 -07001849 if (v instanceof FolderIcon) {
1850 ((FolderIcon) v).removeListeners();
1851 }
Winsonc0b52fe2015-09-09 16:38:15 -07001852 mWorkspace.removeWorkspaceItem(v);
1853 if (deleteFromDb) {
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001854 getModelWriter().deleteFolderAndContentsFromDatabase(folderInfo);
Winsonc0b52fe2015-09-09 16:38:15 -07001855 }
1856 } else if (itemInfo instanceof LauncherAppWidgetInfo) {
1857 final LauncherAppWidgetInfo widgetInfo = (LauncherAppWidgetInfo) itemInfo;
Winson44818e02015-10-02 11:25:46 -07001858 mWorkspace.removeWorkspaceItem(v);
Winsonc0b52fe2015-09-09 16:38:15 -07001859 if (deleteFromDb) {
Tony Wickham6a71a5b2018-08-21 11:40:23 -07001860 getModelWriter().deleteWidgetInfo(widgetInfo, getAppWidgetHost());
Winsonc0b52fe2015-09-09 16:38:15 -07001861 }
1862 } else {
1863 return false;
1864 }
1865 return true;
1866 }
1867
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001868 @Override
1869 public boolean dispatchKeyEvent(KeyEvent event) {
vadimtd633c9c2020-01-22 18:00:37 -08001870 TestLogging.recordEvent(TestProtocol.SEQUENCE_MAIN, "Key event", event);
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08001871 return (event.getKeyCode() == KeyEvent.KEYCODE_HOME) || super.dispatchKeyEvent(event);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001872 }
1873
Joe Onorato88ec0992009-11-19 13:16:06 -08001874 @Override
vadimt9af34a72020-01-21 11:19:13 -08001875 public boolean dispatchTouchEvent(MotionEvent ev) {
Sunny Goyala306e592020-03-24 01:51:41 -07001876 switch (ev.getAction()) {
1877 case MotionEvent.ACTION_DOWN:
1878 mTouchInProgress = true;
1879 break;
1880 case MotionEvent.ACTION_UP:
Riddle Hsub30adcb2020-10-07 15:57:44 +08001881 mLastTouchUpTime = SystemClock.uptimeMillis();
Sunny Goyala306e592020-03-24 01:51:41 -07001882 // Follow through
1883 case MotionEvent.ACTION_CANCEL:
1884 mTouchInProgress = false;
1885 break;
Sunny Goyal9b180102020-03-11 10:02:29 -07001886 }
vadimtd633c9c2020-01-22 18:00:37 -08001887 TestLogging.recordMotionEvent(TestProtocol.SEQUENCE_MAIN, "Touch event", ev);
vadimt9af34a72020-01-21 11:19:13 -08001888 return super.dispatchTouchEvent(ev);
1889 }
1890
Sunny Goyala306e592020-03-24 01:51:41 -07001891 /**
1892 * Returns true if a touch interaction is in progress
1893 */
1894 public boolean isTouchInProgress() {
1895 return mTouchInProgress;
1896 }
1897
vadimt9af34a72020-01-21 11:19:13 -08001898 @Override
Joe Onorato88ec0992009-11-19 13:16:06 -08001899 public void onBackPressed() {
Sunny Goyal7c8a65e2017-12-22 11:11:33 -08001900 if (finishAutoCancelActionMode()) {
1901 return;
1902 }
Adam Cohen9211d422014-10-07 18:14:53 -07001903
Sunny Goyal45478022015-06-08 16:52:41 -07001904 if (mDragController.isDragging()) {
1905 mDragController.cancelDrag();
Adam Cohenc9735cf2015-01-23 16:11:55 -08001906 return;
1907 }
1908
Jon Mirandafeba90f2016-10-06 10:53:29 -07001909 // Note: There should be at most one log per method call. This is enforced implicitly
1910 // by using if-else statements.
Sunny Goyal740ac7f2016-09-28 16:47:32 -07001911 AbstractFloatingView topView = AbstractFloatingView.getTopOpenView(this);
Tony Wickham52c1b662018-05-21 13:13:58 -07001912 if (topView != null && topView.onBackPressed()) {
1913 // Handled by the floating view.
Patrick Dubroy94f78a52011-02-28 17:39:16 -08001914 } else {
Sunny Goyale39690b2018-08-02 13:35:07 -07001915 mStateManager.getState().onBackPressed(this);
Michael Jurkaaf442092010-06-10 17:01:57 -07001916 }
Joe Onorato88ec0992009-11-19 13:16:06 -08001917 }
1918
Sunny Goyalfe770c92016-09-27 14:38:58 -07001919 @TargetApi(Build.VERSION_CODES.M)
Sunny Goyal0b0847b2018-03-14 12:30:11 -07001920 @Override
Sunny Goyal0b0847b2018-03-14 12:30:11 -07001921 protected boolean onErrorStartingShortcut(Intent intent, ItemInfo info) {
1922 // Due to legacy reasons, direct call shortcuts require Launchers to have the
1923 // corresponding permission. Show the appropriate permission prompt if that
1924 // is the case.
1925 if (intent.getComponent() == null
1926 && Intent.ACTION_CALL.equals(intent.getAction())
1927 && checkSelfPermission(android.Manifest.permission.CALL_PHONE) !=
1928 PackageManager.PERMISSION_GRANTED) {
1929
1930 setWaitingForResult(PendingRequestArgs
1931 .forIntent(REQUEST_PERMISSION_CALL_PHONE, intent, info));
1932 requestPermissions(new String[]{android.Manifest.permission.CALL_PHONE},
1933 REQUEST_PERMISSION_CALL_PHONE);
1934 return true;
1935 } else {
1936 return false;
1937 }
Sunny Goyal0eca4e22016-07-20 11:43:06 -07001938 }
1939
Hyunyoung Song46d07f72018-05-22 15:41:25 -07001940 @Override
Sunny Goyal852537f2020-07-15 17:02:16 -07001941 public boolean startActivitySafely(View v, Intent intent, ItemInfo item) {
Tony Wickham794fe4f2021-01-11 14:54:23 -06001942 if (isViewInTaskbar(v)) {
1943 // Start the activity without the hacky workarounds below, which assume the View was
1944 // clicked when Launcher was resumed and will be hidden until Launcher is re-resumed
1945 // (this isn't the case for Taskbar).
1946 return super.startActivitySafely(v, intent, item);
1947 }
1948
Winson Chung0b70cd42019-06-17 22:34:33 -07001949 if (!hasBeenResumed()) {
1950 // Workaround an issue where the WM launch animation is clobbered when finishing the
1951 // recents animation into launcher. Defer launching the activity until Launcher is
1952 // next resumed.
Sunny Goyal852537f2020-07-15 17:02:16 -07001953 addOnResumeCallback(() -> startActivitySafely(v, intent, item));
Winson Chungc9bf6d42019-10-04 15:33:18 -07001954 if (mOnDeferredActivityLaunchCallback != null) {
1955 mOnDeferredActivityLaunchCallback.run();
1956 mOnDeferredActivityLaunchCallback = null;
1957 }
Winson Chung0b70cd42019-06-17 22:34:33 -07001958 return true;
1959 }
1960
Sunny Goyal852537f2020-07-15 17:02:16 -07001961 boolean success = super.startActivitySafely(v, intent, item);
Hyunyoung Song1241e612018-05-15 21:46:51 -07001962 if (success && v instanceof BubbleTextView) {
Sunny Goyal0b0847b2018-03-14 12:30:11 -07001963 // This is set to the view that launched the activity that navigated the user away
1964 // from launcher. Since there is no callback for when the activity has finished
1965 // launching, enable the press state and keep this reference to reset the press
1966 // state when we return to launcher.
1967 BubbleTextView btv = (BubbleTextView) v;
1968 btv.setStayPressed(true);
Sunny Goyalb65d7662021-03-07 15:09:11 -08001969 addOnResumeCallback(() -> btv.setStayPressed(false));
Sunny Goyala7ce1662016-05-31 15:01:35 -07001970 }
Hyunyoung Song1241e612018-05-15 21:46:51 -07001971 return success;
Michael Jurka86a720e2012-05-09 11:23:23 -07001972 }
1973
Winson Chung3d503fb2011-07-13 17:25:49 -07001974 boolean isHotseatLayout(View layout) {
Sunny Goyalc13403c2016-11-18 23:44:48 -08001975 // TODO: Remove this method
Sunny Goyal876e4622018-11-02 13:50:40 -07001976 return mHotseat != null && (layout == mHotseat);
Winson Chung3d503fb2011-07-13 17:25:49 -07001977 }
Romain Guy1fbc1c82009-11-09 20:43:08 -08001978
Winson Chung3d503fb2011-07-13 17:25:49 -07001979 /**
1980 * Returns the CellLayout of the specified container at the specified screen.
1981 */
Sunny Goyalefb7e842018-10-04 15:11:00 -07001982 public CellLayout getCellLayout(int container, int screenId) {
Sunny Goyal876e4622018-11-02 13:50:40 -07001983 return (container == LauncherSettings.Favorites.CONTAINER_HOTSEAT)
1984 ? mHotseat : mWorkspace.getScreenWithId(screenId);
Romain Guya6abce82009-11-10 02:54:41 -08001985 }
1986
Michael Jurkae326f182011-11-21 14:05:46 -08001987 @Override
1988 public void onTrimMemory(int level) {
1989 super.onTrimMemory(level);
Adam Cohen3f9c9712014-10-31 11:48:25 -07001990 if (level >= ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN) {
1991 // The widget preview db can result in holding onto over
1992 // 3MB of memory for caching which isn't necessary.
1993 SQLiteDatabase.releaseMemory();
1994
Adam Cohenc8f4e1b2014-11-19 16:03:20 -08001995 // This clears all widget bitmaps from the widget tray
Hyunyoung Song3f471442015-04-08 19:01:34 -07001996 // TODO(hyunyoungs)
Michael Jurkae326f182011-11-21 14:05:46 -08001997 }
1998 }
1999
Michael Jurkad7c28052012-04-27 15:43:36 -07002000 @Override
2001 public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
alanv1d4fde62012-10-17 13:15:47 -07002002 final boolean result = super.dispatchPopulateAccessibilityEvent(event);
Michael Jurkad7c28052012-04-27 15:43:36 -07002003 final List<CharSequence> text = event.getText();
2004 text.clear();
alanv1d4fde62012-10-17 13:15:47 -07002005 // Populate event with a fake title based on the current state.
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07002006 // TODO: When can workspace be null?
2007 text.add(mWorkspace == null
Sunny Goyal52e25452020-07-20 12:38:01 -07002008 ? getString(R.string.home_screen)
Sunny Goyalea609262017-10-25 15:47:38 -07002009 : mStateManager.getState().getDescription(this));
Michael Jurkad7c28052012-04-27 15:43:36 -07002010 return result;
2011 }
2012
Michael Jurka7607c2f2013-04-03 14:33:19 -07002013 /**
Winson Chungc9bf6d42019-10-04 15:33:18 -07002014 * Persistant callback which notifies when an activity launch is deferred because the activity
2015 * was not yet resumed.
2016 */
2017 public void setOnDeferredActivityLaunchCallback(Runnable callback) {
2018 mOnDeferredActivityLaunchCallback = callback;
2019 }
2020
2021 /**
Sunny Goyala7a5bf32020-01-05 15:35:29 +05302022 * Sets the next page to bind synchronously on next bind.
2023 * @param page
2024 */
2025 public void setPageToBindSynchronously(int page) {
2026 mPageToBindSynchronously = page;
2027 }
2028
2029 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04002030 * Implementation of the method from LauncherModel.Callbacks.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002031 */
Sunny Goyal93f878c2016-03-30 17:31:24 -07002032 @Override
Sunny Goyala7a5bf32020-01-05 15:35:29 +05302033 public int getPageToBindSynchronously() {
2034 if (mPageToBindSynchronously != PagedView.INVALID_PAGE) {
2035 return mPageToBindSynchronously;
2036 } else if (mWorkspace != null) {
Michael Jurka0142d492010-08-25 17:46:15 -07002037 return mWorkspace.getCurrentPage();
Joe Onoratod0afc872010-06-11 00:03:15 -07002038 } else {
Winson Chung882a52e2015-07-08 14:32:26 -07002039 return 0;
Joe Onoratod0afc872010-06-11 00:03:15 -07002040 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04002041 }
The Android Open Source Projectf96811c2009-03-18 17:39:48 -07002042
Joe Onorato9c1289c2009-08-17 11:03:03 -04002043 /**
Sunny Goyal527c7d32015-08-28 15:19:36 -07002044 * Clear any pending bind callbacks. This is called when is loader is planning to
2045 * perform a full rebind from scratch.
2046 */
2047 @Override
2048 public void clearPendingBinds() {
Sunny Goyal527c7d32015-08-28 15:19:36 -07002049 if (mPendingExecutor != null) {
2050 mPendingExecutor.markCompleted();
2051 mPendingExecutor = null;
Sunny Goyal6b6d0a32019-08-05 17:19:32 -07002052
2053 // We might have set this flag previously and forgot to clear it.
2054 mAppsView.getAppsStore()
2055 .disableDeferUpdatesSilently(AllAppsStore.DEFER_UPDATES_NEXT_DRAW);
Sunny Goyal527c7d32015-08-28 15:19:36 -07002056 }
2057 }
2058
2059 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04002060 * Refreshes the shortcuts shown on the workspace.
2061 *
2062 * Implementation of the method from LauncherModel.Callbacks.
2063 */
2064 public void startBinding() {
Winson Chung5cc62c72019-10-16 11:32:41 -07002065 Object traceToken = TraceHelper.INSTANCE.beginSection("startBinding");
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07002066 // Floating panels (except the full widget sheet) are associated with individual icons. If
2067 // we are starting a fresh bind, close all such panels as all the icons are about
2068 // to go away.
Pinyao Tinga74b63a2019-07-17 23:26:06 -07002069 AbstractFloatingView.closeOpenViews(this, true, TYPE_ALL & ~TYPE_REBIND_SAFE);
Jon Miranda6dc7f1e2017-02-21 12:37:51 -08002070
Anjali Koppalff7ceff2014-05-01 18:26:37 -07002071 setWorkspaceLoading(true);
Adam Cohen517a7f52014-03-01 12:12:59 -08002072
Winson Chungd64d1762013-08-20 14:37:16 -07002073 // Clear the workspace because it's going to be rebound
Sunny Goyal2db53422019-03-01 16:06:12 -08002074 mDragController.cancelDrag();
2075
Adam Cohendf035382011-04-11 17:22:04 -07002076 mWorkspace.clearDropTargets();
Winson Chung9e6a0a22013-08-27 11:58:12 -07002077 mWorkspace.removeAllWorkspaceScreens();
Sunny Goyalc11fac32018-02-27 19:20:15 -08002078 mAppWidgetHost.clearViews();
Winson Chungd64d1762013-08-20 14:37:16 -07002079
Winson Chung3d503fb2011-07-13 17:25:49 -07002080 if (mHotseat != null) {
Sunny Goyalc4d32012020-04-03 17:10:11 -07002081 mHotseat.resetLayout(getDeviceProfile().isVerticalBarLayout());
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002082 }
Winson Chung5cc62c72019-10-16 11:32:41 -07002083 TraceHelper.INSTANCE.endSection(traceToken);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002084 }
2085
Adam Cohendcd297f2013-06-18 13:13:40 -07002086 @Override
Sunny Goyalefb7e842018-10-04 15:11:00 -07002087 public void bindScreens(IntArray orderedScreenIds) {
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002088 // Make sure the first screen is always at the start.
Jon Miranda7143ba62019-03-15 09:00:05 -07002089 if (FeatureFlags.QSB_ON_FIRST_SCREEN &&
Sunny Goyala9e2f5a2016-06-10 12:22:04 -07002090 orderedScreenIds.indexOf(Workspace.FIRST_SCREEN_ID) != 0) {
Sunny Goyalefb7e842018-10-04 15:11:00 -07002091 orderedScreenIds.removeValue(Workspace.FIRST_SCREEN_ID);
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002092 orderedScreenIds.add(0, Workspace.FIRST_SCREEN_ID);
Jon Miranda7143ba62019-03-15 09:00:05 -07002093 } else if (!FeatureFlags.QSB_ON_FIRST_SCREEN && orderedScreenIds.isEmpty()) {
Sunny Goyala9e2f5a2016-06-10 12:22:04 -07002094 // If there are no screens, we need to have an empty screen
2095 mWorkspace.addExtraEmptyScreen();
Adam Cohen5084cba2013-09-03 12:01:16 -07002096 }
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002097 bindAddScreens(orderedScreenIds);
Winson Chung0e6a7132013-08-23 12:55:10 -07002098
Winsonc7d2e832016-07-28 12:24:55 -07002099 // After we have added all the screens, if the wallpaper was locked to the default state,
2100 // then notify to indicate that it can be released and a proper wallpaper offset can be
2101 // computed before the next layout
2102 mWorkspace.unlockWallpaperFromDefaultPageOnNextLayout();
Winson Chung64359a52013-07-08 17:17:08 -07002103 }
2104
Sunny Goyalefb7e842018-10-04 15:11:00 -07002105 private void bindAddScreens(IntArray orderedScreenIds) {
Adam Cohendcd297f2013-06-18 13:13:40 -07002106 int count = orderedScreenIds.size();
2107 for (int i = 0; i < count; i++) {
Sunny Goyalefb7e842018-10-04 15:11:00 -07002108 int screenId = orderedScreenIds.get(i);
Jon Miranda7143ba62019-03-15 09:00:05 -07002109 if (!FeatureFlags.QSB_ON_FIRST_SCREEN || screenId != Workspace.FIRST_SCREEN_ID) {
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002110 // No need to bind the first screen, as its always bound.
2111 mWorkspace.insertNewWorkspaceScreenBeforeEmptyScreen(screenId);
2112 }
Adam Cohendcd297f2013-06-18 13:13:40 -07002113 }
Adam Cohendcd297f2013-06-18 13:13:40 -07002114 }
2115
Sunny Goyalb23980c2017-08-17 07:45:25 -07002116 @Override
Tony Wickham6a71a5b2018-08-21 11:40:23 -07002117 public void preAddApps() {
2118 // If there's an undo snackbar, force it to complete to ensure empty screens are removed
2119 // before trying to add new items.
2120 mModelWriter.commitDelete();
2121 AbstractFloatingView snackbar = AbstractFloatingView.getOpenView(this, TYPE_SNACKBAR);
2122 if (snackbar != null) {
2123 snackbar.post(() -> snackbar.close(true));
2124 }
2125 }
2126
2127 @Override
Sunny Goyalefb7e842018-10-04 15:11:00 -07002128 public void bindAppsAdded(IntArray newScreens, ArrayList<ItemInfo> addNotAnimated,
Sunny Goyal29947f02017-12-18 13:49:44 -08002129 ArrayList<ItemInfo> addAnimated) {
Winson Chungd64d1762013-08-20 14:37:16 -07002130 // Add the new screens
Adam Cohen76a47a12014-02-05 11:47:43 -08002131 if (newScreens != null) {
2132 bindAddScreens(newScreens);
2133 }
Winson Chungd64d1762013-08-20 14:37:16 -07002134
2135 // We add the items without animation on non-visible pages, and with
2136 // animations on the new page (which we will try and snap to).
Adam Cohen76a47a12014-02-05 11:47:43 -08002137 if (addNotAnimated != null && !addNotAnimated.isEmpty()) {
Sunny Goyalb23980c2017-08-17 07:45:25 -07002138 bindItems(addNotAnimated, false);
Winson Chungd64d1762013-08-20 14:37:16 -07002139 }
Adam Cohen76a47a12014-02-05 11:47:43 -08002140 if (addAnimated != null && !addAnimated.isEmpty()) {
Sunny Goyalb23980c2017-08-17 07:45:25 -07002141 bindItems(addAnimated, true);
Winson Chungd64d1762013-08-20 14:37:16 -07002142 }
Winson Chungc58497e2013-09-03 17:48:37 -07002143
Winson Chung87412982013-10-03 18:34:14 -07002144 // Remove the extra empty screen
Sunny Goyal6e379fc2020-03-19 16:08:14 -07002145 mWorkspace.removeExtraEmptyScreen(false);
Winson Chungd64d1762013-08-20 14:37:16 -07002146 }
2147
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002148 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04002149 * Bind the items start-end from the list.
2150 *
2151 * Implementation of the method from LauncherModel.Callbacks.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002152 */
Tony Wickham0bb211a2015-10-02 16:22:08 -07002153 @Override
Sunny Goyalb23980c2017-08-17 07:45:25 -07002154 public void bindItems(final List<ItemInfo> items, final boolean forceAnimateIcons) {
Sunny Goyal3be633b2016-12-08 09:59:25 -08002155 // Get the list of added items and intersect them with the set of items here
Rajeev Kumar43c0f582017-06-23 15:34:55 -07002156 final Collection<Animator> bounceAnims = new ArrayList<>();
Winson Chung997a9232013-07-24 15:33:46 -07002157 final boolean animateIcons = forceAnimateIcons && canRunNewAppsAnimation();
Winson Chungf0c6ae02012-03-21 16:10:31 -07002158 Workspace workspace = mWorkspace;
Sunny Goyalefb7e842018-10-04 15:11:00 -07002159 int newItemsScreenId = -1;
Sunny Goyalb23980c2017-08-17 07:45:25 -07002160 int end = items.size();
2161 for (int i = 0; i < end; i++) {
Sunny Goyal3be633b2016-12-08 09:59:25 -08002162 final ItemInfo item = items.get(i);
Winson Chung4d279d92011-07-21 11:46:32 -07002163
2164 // Short circuit if we are loading dock items for a configuration which has no dock
2165 if (item.container == LauncherSettings.Favorites.CONTAINER_HOTSEAT &&
2166 mHotseat == null) {
2167 continue;
2168 }
2169
Sunny Goyal639e9062015-08-19 19:17:06 -07002170 final View view;
Joe Onorato9c1289c2009-08-17 11:03:03 -04002171 switch (item.itemType) {
2172 case LauncherSettings.Favorites.ITEM_TYPE_APPLICATION:
2173 case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT:
Sunny Goyal3be633b2016-12-08 09:59:25 -08002174 case LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT: {
Sunny Goyal95899162019-03-27 16:03:06 -07002175 WorkspaceItemInfo info = (WorkspaceItemInfo) item;
Sunny Goyal639e9062015-08-19 19:17:06 -07002176 view = createShortcut(info);
Joe Onorato9c1289c2009-08-17 11:03:03 -04002177 break;
Sunny Goyal3be633b2016-12-08 09:59:25 -08002178 }
2179 case LauncherSettings.Favorites.ITEM_TYPE_FOLDER: {
Tracy Zhou4d7b2442019-12-09 13:42:57 -08002180 view = FolderIcon.inflateFolderAndIcon(R.layout.folder_icon, this,
Michael Jurka0142d492010-08-25 17:46:15 -07002181 (ViewGroup) workspace.getChildAt(workspace.getCurrentPage()),
Sunny Goyal1cd01b02016-11-09 10:43:58 -08002182 (FolderInfo) item);
Joe Onorato9c1289c2009-08-17 11:03:03 -04002183 break;
Sunny Goyal3be633b2016-12-08 09:59:25 -08002184 }
Sunny Goyal952e63d2017-08-16 04:59:08 -07002185 case LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET:
2186 case LauncherSettings.Favorites.ITEM_TYPE_CUSTOM_APPWIDGET: {
Sunny Goyala9a1a212017-08-18 01:03:21 -07002187 view = inflateAppWidget((LauncherAppWidgetInfo) item);
Sunny Goyalb23980c2017-08-17 07:45:25 -07002188 if (view == null) {
2189 continue;
Sunny Goyal3be633b2016-12-08 09:59:25 -08002190 }
Sunny Goyal3be633b2016-12-08 09:59:25 -08002191 break;
2192 }
Winson Chungc763c4e2013-07-19 13:49:06 -07002193 default:
2194 throw new RuntimeException("Invalid Item Type");
Joe Onorato9c1289c2009-08-17 11:03:03 -04002195 }
Sunny Goyal639e9062015-08-19 19:17:06 -07002196
Samuel Fufaca37b8a2019-08-19 17:04:36 -07002197 /*
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002198 * Remove colliding items.
2199 */
2200 if (item.container == LauncherSettings.Favorites.CONTAINER_DESKTOP) {
2201 CellLayout cl = mWorkspace.getScreenWithId(item.screenId);
2202 if (cl != null && cl.isOccupied(item.cellX, item.cellY)) {
2203 View v = cl.getChildAt(item.cellX, item.cellY);
2204 Object tag = v.getTag();
2205 String desc = "Collision while binding workspace item: " + item
2206 + ". Collides with " + tag;
Zak Cohen3eeb41d2020-02-14 14:15:13 -08002207 if (FeatureFlags.IS_STUDIO_BUILD) {
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002208 throw (new RuntimeException(desc));
2209 } else {
2210 Log.d(TAG, desc);
Sunny Goyal43bf11d2017-02-02 13:52:53 -08002211 getModelWriter().deleteItemFromDatabase(item);
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002212 continue;
2213 }
2214 }
2215 }
Sunny Goyald5462aa2016-11-22 16:52:39 +05302216 workspace.addInScreenFromBind(view, item);
Sunny Goyal639e9062015-08-19 19:17:06 -07002217 if (animateIcons) {
2218 // Animate all the applications up now
2219 view.setAlpha(0f);
2220 view.setScaleX(0f);
2221 view.setScaleY(0f);
2222 bounceAnims.add(createNewAppBounceAnimation(view, i));
Sunny Goyal3be633b2016-12-08 09:59:25 -08002223 newItemsScreenId = item.screenId;
Sunny Goyal639e9062015-08-19 19:17:06 -07002224 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002225 }
Winson Chungf0c6ae02012-03-21 16:10:31 -07002226
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002227 // Animate to the correct page
2228 if (animateIcons && newItemsScreenId > -1) {
2229 AnimatorSet anim = new AnimatorSet();
2230 anim.playTogether(bounceAnims);
Jon Miranda64eb8ea2018-03-29 11:43:58 -07002231
Sunny Goyalefb7e842018-10-04 15:11:00 -07002232 int currentScreenId = mWorkspace.getScreenIdForPageIndex(mWorkspace.getNextPage());
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002233 final int newScreenIndex = mWorkspace.getPageIndexForScreenId(newItemsScreenId);
2234 final Runnable startBounceAnimRunnable = anim::start;
2235
2236 if (newItemsScreenId != currentScreenId) {
2237 // We post the animation slightly delayed to prevent slowdowns
2238 // when we are loading right after we return to launcher.
2239 mWorkspace.postDelayed(new Runnable() {
2240 public void run() {
2241 if (mWorkspace != null) {
Andy Wickham65ced1b2020-03-07 02:14:19 +00002242 closeOpenViews(false);
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002243
2244 mWorkspace.snapToPage(newScreenIndex);
2245 mWorkspace.postDelayed(startBounceAnimRunnable,
2246 NEW_APPS_ANIMATION_DELAY);
Winson Chung94d67682013-09-25 16:29:40 -07002247 }
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002248 }
2249 }, NEW_APPS_PAGE_MOVE_DELAY);
2250 } else {
2251 mWorkspace.postDelayed(startBounceAnimRunnable, NEW_APPS_ANIMATION_DELAY);
Winson Chung997a9232013-07-24 15:33:46 -07002252 }
Winson Chung64359a52013-07-08 17:17:08 -07002253 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04002254 workspace.requestLayout();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002255 }
2256
Joe Onorato9c1289c2009-08-17 11:03:03 -04002257 /**
2258 * Add the views for a widget to the workspace.
Joe Onorato9c1289c2009-08-17 11:03:03 -04002259 */
Sunny Goyala9a1a212017-08-18 01:03:21 -07002260 public void bindAppWidget(LauncherAppWidgetInfo item) {
2261 View view = inflateAppWidget(item);
2262 if (view != null) {
2263 mWorkspace.addInScreen(view, item);
2264 mWorkspace.requestLayout();
2265 }
2266 }
2267
2268 private View inflateAppWidget(LauncherAppWidgetInfo item) {
Samuel Fufaca37b8a2019-08-19 17:04:36 -07002269 if (item.hasOptionFlag(LauncherAppWidgetInfo.OPTION_SEARCH_WIDGET)) {
2270 item.providerName = QsbContainerView.getSearchComponentName(this);
2271 if (item.providerName == null) {
2272 getModelWriter().deleteItemFromDatabase(item);
2273 return null;
2274 }
2275 }
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002276 final AppWidgetHostView view;
Sunny Goyal2e1efb42016-03-03 16:58:55 -08002277 if (mIsSafeModeEnabled) {
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002278 view = new PendingAppWidgetHostView(this, item, mIconCache, true);
Sunny Goyald5462aa2016-11-22 16:52:39 +05302279 prepareAppWidget(view, item);
Sunny Goyalb23980c2017-08-17 07:45:25 -07002280 return view;
Sunny Goyal2e1efb42016-03-03 16:58:55 -08002281 }
2282
Winson Chung5cc62c72019-10-16 11:32:41 -07002283 Object traceToken = TraceHelper.INSTANCE.beginSection("BIND_WIDGET_id=" + item.appWidgetId);
Joe Onorato9c1289c2009-08-17 11:03:03 -04002284
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002285 try {
2286 final LauncherAppWidgetProviderInfo appWidgetInfo;
Adam Cohen59400422014-03-05 18:07:04 -08002287
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002288 if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY)) {
2289 // If the provider is not ready, bind as a pending widget.
2290 appWidgetInfo = null;
2291 } else if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)) {
2292 // The widget id is not valid. Try to find the widget based on the provider info.
2293 appWidgetInfo = mAppWidgetManager.findProvider(item.providerName, item.user);
2294 } else {
2295 appWidgetInfo = mAppWidgetManager.getLauncherAppWidgetInfo(item.appWidgetId);
Sunny Goyalff572272014-07-23 13:58:07 -07002296 }
Sunny Goyalff572272014-07-23 13:58:07 -07002297
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002298 // If the provider is ready, but the width is not yet restored, try to restore it.
2299 if (!item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY)
2300 && (item.restoreStatus != LauncherAppWidgetInfo.RESTORE_COMPLETED)) {
2301 if (appWidgetInfo == null) {
2302 Log.d(TAG, "Removing restored widget: id=" + item.appWidgetId
2303 + " belongs to component " + item.providerName
2304 + ", as the provider is null");
2305 getModelWriter().deleteItemFromDatabase(item);
2306 return null;
2307 }
Sunny Goyalff572272014-07-23 13:58:07 -07002308
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002309 // If we do not have a valid id, try to bind an id.
2310 if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)) {
2311 if (!item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_ALLOCATED)) {
2312 // Id has not been allocated yet. Allocate a new id.
2313 item.appWidgetId = mAppWidgetHost.allocateAppWidgetId();
2314 item.restoreStatus |= LauncherAppWidgetInfo.FLAG_ID_ALLOCATED;
Sunny Goyal86df1382016-08-10 15:03:22 -07002315
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002316 // Also try to bind the widget. If the bind fails, the user will be shown
2317 // a click to setup UI, which will ask for the bind permission.
2318 PendingAddWidgetInfo pendingInfo = new PendingAddWidgetInfo(appWidgetInfo);
2319 pendingInfo.spanX = item.spanX;
2320 pendingInfo.spanY = item.spanY;
2321 pendingInfo.minSpanX = item.minSpanX;
2322 pendingInfo.minSpanY = item.minSpanY;
2323 Bundle options = WidgetHostViewLoader.getDefaultOptionsForWidget(this,
2324 pendingInfo);
2325
2326 boolean isDirectConfig =
2327 item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_DIRECT_CONFIG);
2328 if (isDirectConfig && item.bindOptions != null) {
2329 Bundle newOptions = item.bindOptions.getExtras();
2330 if (options != null) {
2331 newOptions.putAll(options);
2332 }
2333 options = newOptions;
Sunny Goyal86df1382016-08-10 15:03:22 -07002334 }
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002335 boolean success = mAppWidgetManager.bindAppWidgetIdIfAllowed(
2336 item.appWidgetId, appWidgetInfo, options);
2337
2338 // We tried to bind once. If we were not able to bind, we would need to
2339 // go through the permission dialog, which means we cannot skip the config
2340 // activity.
2341 item.bindOptions = null;
2342 item.restoreStatus &= ~LauncherAppWidgetInfo.FLAG_DIRECT_CONFIG;
2343
2344 // Bind succeeded
2345 if (success) {
2346 // If the widget has a configure activity, it is still needs to set it
2347 // up, otherwise the widget is ready to go.
2348 item.restoreStatus = (appWidgetInfo.configure == null) || isDirectConfig
2349 ? LauncherAppWidgetInfo.RESTORE_COMPLETED
2350 : LauncherAppWidgetInfo.FLAG_UI_NOT_READY;
2351 }
2352
2353 getModelWriter().updateItemInDatabase(item);
Sunny Goyal86df1382016-08-10 15:03:22 -07002354 }
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002355 } else if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_UI_NOT_READY)
2356 && (appWidgetInfo.configure == null)) {
2357 // The widget was marked as UI not ready, but there is no configure activity to
2358 // update the UI.
2359 item.restoreStatus = LauncherAppWidgetInfo.RESTORE_COMPLETED;
Sunny Goyal43bf11d2017-02-02 13:52:53 -08002360 getModelWriter().updateItemInDatabase(item);
Sunny Goyalff572272014-07-23 13:58:07 -07002361 }
Samuel Fufa9151c012020-02-24 17:06:28 -08002362 else if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_UI_NOT_READY)
2363 && appWidgetInfo.configure != null) {
2364 if (mAppWidgetManager.isAppWidgetRestored(item.appWidgetId)) {
2365 item.restoreStatus = LauncherAppWidgetInfo.RESTORE_COMPLETED;
2366 getModelWriter().updateItemInDatabase(item);
2367 }
2368 }
Sunny Goyal56c73602015-09-25 12:55:01 -07002369 }
2370
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002371 if (item.restoreStatus == LauncherAppWidgetInfo.RESTORE_COMPLETED) {
2372 // Verify that we own the widget
2373 if (appWidgetInfo == null) {
Pinyao Ting0d97f8d2020-12-04 15:12:26 -08002374 FileLog.e(TAG, "Removing invalid widget: id=" + item.appWidgetId);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002375 getModelWriter().deleteWidgetInfo(item, getAppWidgetHost());
2376 return null;
2377 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04002378
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002379 item.minSpanX = appWidgetInfo.minSpanX;
2380 item.minSpanY = appWidgetInfo.minSpanY;
2381 view = mAppWidgetHost.createView(this, item.appWidgetId, appWidgetInfo);
Samuel Fufa9151c012020-02-24 17:06:28 -08002382 } else if (!item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)
2383 && appWidgetInfo != null) {
2384 mAppWidgetHost.addPendingView(item.appWidgetId,
2385 new PendingAppWidgetHostView(this, item, mIconCache, false));
2386 view = mAppWidgetHost.createView(this, item.appWidgetId, appWidgetInfo);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002387 } else {
2388 view = new PendingAppWidgetHostView(this, item, mIconCache, false);
2389 }
2390 prepareAppWidget(view, item);
2391 } finally {
Winson Chung5cc62c72019-10-16 11:32:41 -07002392 TraceHelper.INSTANCE.endSection(traceToken);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002393 }
2394
Sunny Goyalb23980c2017-08-17 07:45:25 -07002395 return view;
Joe Onorato9c1289c2009-08-17 11:03:03 -04002396 }
2397
Sunny Goyalff572272014-07-23 13:58:07 -07002398 /**
2399 * Restores a pending widget.
2400 *
2401 * @param appWidgetId The app widget id
Sunny Goyalff572272014-07-23 13:58:07 -07002402 */
Sunny Goyald478c832016-04-01 12:04:16 -07002403 private LauncherAppWidgetInfo completeRestoreAppWidget(int appWidgetId, int finalRestoreFlag) {
Sunny Goyalff572272014-07-23 13:58:07 -07002404 LauncherAppWidgetHostView view = mWorkspace.getWidgetForAppWidgetId(appWidgetId);
2405 if ((view == null) || !(view instanceof PendingAppWidgetHostView)) {
2406 Log.e(TAG, "Widget update called, when the widget no longer exists.");
Sunny Goyald478c832016-04-01 12:04:16 -07002407 return null;
Sunny Goyalff572272014-07-23 13:58:07 -07002408 }
2409
Sunny Goyal0fc1be12014-08-11 17:05:23 -07002410 LauncherAppWidgetInfo info = (LauncherAppWidgetInfo) view.getTag();
Sunny Goyald478c832016-04-01 12:04:16 -07002411 info.restoreStatus = finalRestoreFlag;
Jon Miranda2b823f42017-05-02 18:36:18 -07002412 if (info.restoreStatus == LauncherAppWidgetInfo.RESTORE_COMPLETED) {
2413 info.pendingItemInfo = null;
2414 }
Sunny Goyalff572272014-07-23 13:58:07 -07002415
Sunny Goyalba47faa2017-10-04 16:50:57 -07002416 if (((PendingAppWidgetHostView) view).isReinflateIfNeeded()) {
Sunny Goyal29947f02017-12-18 13:49:44 -08002417 view.reInflate();
Sunny Goyalba47faa2017-10-04 16:50:57 -07002418 }
2419
Sunny Goyal43bf11d2017-02-02 13:52:53 -08002420 getModelWriter().updateItemInDatabase(info);
Sunny Goyald478c832016-04-01 12:04:16 -07002421 return info;
Sunny Goyalff572272014-07-23 13:58:07 -07002422 }
2423
Adam Cohen1462de32012-07-24 22:34:36 -07002424 public void onPageBoundSynchronously(int page) {
Sunny Goyalf4aceab2017-12-06 16:16:31 -08002425 mSynchronouslyBoundPage = page;
Sunny Goyala7a5bf32020-01-05 15:35:29 +05302426 mWorkspace.setCurrentPage(page);
2427 mPageToBindSynchronously = PagedView.INVALID_PAGE;
Adam Cohen1462de32012-07-24 22:34:36 -07002428 }
2429
Sunny Goyal527c7d32015-08-28 15:19:36 -07002430 @Override
2431 public void executeOnNextDraw(ViewOnDrawExecutor executor) {
Sunny Goyal6b6d0a32019-08-05 17:19:32 -07002432 clearPendingBinds();
Sunny Goyal527c7d32015-08-28 15:19:36 -07002433 mPendingExecutor = executor;
Sunny Goyal60180b02018-02-07 12:56:30 -08002434 if (!isInState(ALL_APPS)) {
vadimtd4c90e12019-06-04 13:59:43 -07002435 mAppsView.getAppsStore().enableDeferUpdates(AllAppsStore.DEFER_UPDATES_NEXT_DRAW);
2436 mPendingExecutor.execute(() -> mAppsView.getAppsStore().disableDeferUpdates(
2437 AllAppsStore.DEFER_UPDATES_NEXT_DRAW));
Sunny Goyal60180b02018-02-07 12:56:30 -08002438 }
2439
Sunny Goyal527c7d32015-08-28 15:19:36 -07002440 executor.attachTo(this);
2441 }
2442
2443 public void clearPendingExecutor(ViewOnDrawExecutor executor) {
2444 if (mPendingExecutor == executor) {
2445 mPendingExecutor = null;
2446 }
2447 }
2448
Sunny Goyalb5b9ad62016-04-02 11:23:39 -07002449 @Override
2450 public void finishFirstPageBind(final ViewOnDrawExecutor executor) {
Sunny Goyal6001ea22018-05-10 16:31:00 -07002451 AlphaProperty property = mDragLayer.getAlphaProperty(ALPHA_INDEX_LAUNCHER_LOAD);
2452 if (property.getValue() < 1) {
2453 ObjectAnimator anim = ObjectAnimator.ofFloat(property, MultiValueAlpha.VALUE, 1);
2454 if (executor != null) {
2455 anim.addListener(new AnimatorListenerAdapter() {
2456 @Override
2457 public void onAnimationEnd(Animator animation) {
2458 executor.onLoadAnimationCompleted();
2459 }
2460 });
2461 }
2462 anim.start();
Sunny Goyal29947f02017-12-18 13:49:44 -08002463 } else if (executor != null) {
2464 executor.onLoadAnimationCompleted();
Sunny Goyalb5b9ad62016-04-02 11:23:39 -07002465 }
2466 }
2467
Joe Onorato9c1289c2009-08-17 11:03:03 -04002468 /**
2469 * Callback saying that there aren't any more items to bind.
2470 *
2471 * Implementation of the method from LauncherModel.Callbacks.
2472 */
Tonyf80e8932018-12-21 11:58:04 -08002473 public void finishBindingItems(int pageBoundFirst) {
Winson Chung5cc62c72019-10-16 11:32:41 -07002474 Object traceToken = TraceHelper.INSTANCE.beginSection("finishBindingItems");
Adam Cohen1462de32012-07-24 22:34:36 -07002475 mWorkspace.restoreInstanceStateForRemainingPages();
Joe Onorato9c1289c2009-08-17 11:03:03 -04002476
Anjali Koppalff7ceff2014-05-01 18:26:37 -07002477 setWorkspaceLoading(false);
Adam Cohendb364c32014-05-20 14:23:40 -07002478
Sunny Goyal2100c782016-08-22 16:00:03 -07002479 if (mPendingActivityResult != null) {
2480 handleActivityResult(mPendingActivityResult.requestCode,
2481 mPendingActivityResult.resultCode, mPendingActivityResult.data);
2482 mPendingActivityResult = null;
Adam Cohendb364c32014-05-20 14:23:40 -07002483 }
2484
Sunny Goyal60e68c92020-08-12 13:59:27 -07002485 ItemInstallQueue.INSTANCE.get(this)
2486 .resumeModelPush(FLAG_LOADER_RUNNING);
Adam Cohen9211d422014-10-07 18:14:53 -07002487
Tonyf80e8932018-12-21 11:58:04 -08002488 // When undoing the removal of the last item on a page, return to that page.
Tony Wickham03f27012019-04-25 14:22:54 -07002489 // Since we are just resetting the current page without user interaction,
2490 // override the previous page so we don't log the page switch.
2491 mWorkspace.setCurrentPage(pageBoundFirst, pageBoundFirst /* overridePrevPage */);
Sunny Goyala7a5bf32020-01-05 15:35:29 +05302492 mPageToBindSynchronously = PagedView.INVALID_PAGE;
Tony Wickham6a71a5b2018-08-21 11:40:23 -07002493
Sunny Goyalac6f69f2019-08-16 11:59:55 -07002494 // Cache one page worth of icons
2495 getViewCache().setCacheSize(R.layout.folder_application,
2496 mDeviceProfile.inv.numFolderColumns * mDeviceProfile.inv.numFolderRows);
2497 getViewCache().setCacheSize(R.layout.folder_page, 2);
2498
Winson Chung5cc62c72019-10-16 11:32:41 -07002499 TraceHelper.INSTANCE.endSection(traceToken);
Winson Chungf0c6ae02012-03-21 16:10:31 -07002500 }
2501
Winson Chunga2413752012-04-03 14:22:34 -07002502 private boolean canRunNewAppsAnimation() {
Sunny Goyal9b180102020-03-11 10:02:29 -07002503 if (mDragController.isDragging()) {
2504 return false;
2505 } else {
Riddle Hsu979da642020-09-22 21:52:40 +08002506 return (SystemClock.uptimeMillis() - mLastTouchUpTime)
Sunny Goyal9b180102020-03-11 10:02:29 -07002507 > (NEW_APPS_ANIMATION_INACTIVE_TIMEOUT_SECONDS * 1000);
2508 }
Winson Chunga2413752012-04-03 14:22:34 -07002509 }
2510
Winson Chungc9168342013-06-26 14:54:55 -07002511 private ValueAnimator createNewAppBounceAnimation(View v, int i) {
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002512 ValueAnimator bounceAnim = new PropertyListBuilder().alpha(1).scale(1).build(v)
Sunny Goyal60e68c92020-08-12 13:59:27 -07002513 .setDuration(ItemInstallQueue.NEW_SHORTCUT_BOUNCE_DURATION);
2514 bounceAnim.setStartDelay(i * ItemInstallQueue.NEW_SHORTCUT_STAGGER_DELAY);
Sunny Goyal5a1f53b2015-05-27 10:24:24 -07002515 bounceAnim.setInterpolator(new OvershootInterpolator(BOUNCE_ANIMATION_TENSION));
Winson Chungc9168342013-06-26 14:54:55 -07002516 return bounceAnim;
2517 }
2518
Pinyao Tingc9074272019-11-11 11:51:44 -08002519 private void announceForAccessibility(@StringRes int stringResId) {
2520 getDragLayer().announceForAccessibility(getString(stringResId));
2521 }
2522
Amith Yamasani6d7fe502010-11-16 09:05:07 -08002523 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04002524 * Add the icons for all apps.
2525 *
2526 * Implementation of the method from LauncherModel.Callbacks.
2527 */
Sunny Goyal28daf4a2020-06-08 17:06:09 -07002528 @Override
2529 public void bindAllApplications(AppInfo[] apps, int flags) {
2530 mAppsView.getAppsStore().setApps(apps, flags);
Sunny Goyal1818fb72020-11-09 14:32:48 -08002531 PopupContainerWithArrow.dismissInvalidPopup(this);
Joe Onorato9c1289c2009-08-17 11:03:03 -04002532 }
2533
2534 /**
Zak Cohen658c67a2018-10-19 14:21:05 -07002535 * Copies LauncherModel's map of activities to shortcut counts to Launcher's. This is necessary
Tony Wickhambfbf7f92016-05-19 11:19:39 -07002536 * because LauncherModel's map is updated in the background, while Launcher runs on the UI.
2537 */
2538 @Override
Zak Cohen658c67a2018-10-19 14:21:05 -07002539 public void bindDeepShortcutMap(HashMap<ComponentKey, Integer> deepShortcutMapCopy) {
Tony Wickham010d2552017-01-20 08:15:28 -08002540 mPopupDataProvider.setDeepShortcutMap(deepShortcutMapCopy);
Tony Wickham1bce7fd2016-04-28 17:39:03 -07002541 }
2542
Sunny Goyal4390ace2014-10-13 11:33:11 -07002543 @Override
Schneider Victor-tulias6a5f4312021-01-12 19:30:02 +00002544 public void bindIncrementalDownloadProgressUpdated(AppInfo app) {
2545 mAppsView.getAppsStore().updateProgressBar(app);
Mario Bertschler08ffaae2017-03-20 11:30:27 -07002546 }
2547
2548 @Override
Sunny Goyal29947f02017-12-18 13:49:44 -08002549 public void bindWidgetsRestored(ArrayList<LauncherAppWidgetInfo> widgets) {
Sunny Goyal4390ace2014-10-13 11:33:11 -07002550 mWorkspace.widgetsRestored(widgets);
2551 }
2552
Joe Onorato9c1289c2009-08-17 11:03:03 -04002553 /**
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07002554 * Some shortcuts were updated in the background.
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07002555 * Implementation of the method from LauncherModel.Callbacks.
Sunny Goyald3b87ef2016-07-28 12:11:54 -07002556 *
2557 * @param updated list of shortcuts which have changed.
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07002558 */
Sunny Goyal4390ace2014-10-13 11:33:11 -07002559 @Override
Sunny Goyal28f50752020-07-21 14:15:13 -07002560 public void bindWorkspaceItemsChanged(List<WorkspaceItemInfo> updated) {
Sunny Goyal4390ace2014-10-13 11:33:11 -07002561 if (!updated.isEmpty()) {
2562 mWorkspace.updateShortcuts(updated);
Sunny Goyal1818fb72020-11-09 14:32:48 -08002563 PopupContainerWithArrow.dismissInvalidPopup(this);
Sunny Goyal4390ace2014-10-13 11:33:11 -07002564 }
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07002565 }
2566
2567 /**
Chris Wrenaeff7ea2014-02-14 16:59:24 -05002568 * Update the state of a package, typically related to install state.
2569 *
2570 * Implementation of the method from LauncherModel.Callbacks.
2571 */
Sunny Goyale755d462014-07-22 13:48:29 -07002572 @Override
Sunny Goyal29947f02017-12-18 13:49:44 -08002573 public void bindRestoreItemsChange(HashSet<ItemInfo> updates) {
Sunny Goyal756adbc2015-04-16 15:20:51 -07002574 mWorkspace.updateRestoreItems(updates);
Sunny Goyala22666f2014-09-18 13:25:15 -07002575 }
2576
2577 /**
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07002578 * A package was uninstalled/updated. We take both the super set of packageNames
Winson Chung83892cc2013-05-01 16:53:33 -07002579 * in addition to specific applications to remove, the reason being that
2580 * this can be called when a package is updated as well. In that scenario,
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07002581 * we only remove specific components from the workspace and hotseat, where as
Winson Chung83892cc2013-05-01 16:53:33 -07002582 * package-removal should clear all items by package name.
Joe Onorato9c1289c2009-08-17 11:03:03 -04002583 */
Sunny Goyal1a745e82014-10-02 15:58:31 -07002584 @Override
Sunny Goyal6e13dd32017-08-17 03:01:19 -07002585 public void bindWorkspaceComponentsRemoved(final ItemInfoMatcher matcher) {
Sunny Goyal6e13dd32017-08-17 03:01:19 -07002586 mWorkspace.removeItemsByMatcher(matcher);
2587 mDragController.onAppsRemoved(matcher);
Sunny Goyal1818fb72020-11-09 14:32:48 -08002588 PopupContainerWithArrow.dismissInvalidPopup(this);
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07002589 }
Sunny Goyal4390ace2014-10-13 11:33:11 -07002590
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07002591 @Override
Steven Ng2f5648a2021-02-08 17:18:25 +00002592 public void bindAllWidgets(final List<WidgetsListBaseEntry> allWidgets) {
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07002593 mPopupDataProvider.setAllWidgets(allWidgets);
Tony Wickham26b17462017-03-20 17:12:24 -07002594 }
2595
Tony Wickham86222d22017-03-29 15:30:43 -07002596 /**
2597 * @param packageUser if null, refreshes all widgets and shortcuts, otherwise only
2598 * refreshes the widgets and shortcuts associated with the given package/user
2599 */
2600 public void refreshAndBindWidgetsForPackageUser(@Nullable PackageUserKey packageUser) {
Sunny Goyalc6e97692017-06-02 13:46:55 -07002601 mModel.refreshAndBindWidgetsAndShortcuts(packageUser);
Sunny Goyal2e1efb42016-03-03 16:58:55 -08002602 }
2603
Winson Chung80baf5a2010-08-09 16:03:15 -07002604 /**
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08002605 * $ adb shell dumpsys activity com.android.launcher3.Launcher [--all]
Joe Onoratobe386092009-11-17 17:32:16 -08002606 */
Adam Cohen16d7ffc2011-10-05 17:49:14 -07002607 @Override
2608 public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) {
2609 super.dump(prefix, fd, writer, args);
Sunny Goyala1365452015-10-01 15:46:24 -07002610
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08002611 if (args.length > 0 && TextUtils.equals(args[0], "--all")) {
2612 writer.println(prefix + "Workspace Items");
Sunny Goyal7ce471b2017-08-02 03:37:39 -07002613 for (int i = 0; i < mWorkspace.getPageCount(); i++) {
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08002614 writer.println(prefix + " Homescreen " + i);
2615
2616 ViewGroup layout = ((CellLayout) mWorkspace.getPageAt(i)).getShortcutsAndWidgets();
2617 for (int j = 0; j < layout.getChildCount(); j++) {
2618 Object tag = layout.getChildAt(j).getTag();
2619 if (tag != null) {
2620 writer.println(prefix + " " + tag.toString());
2621 }
2622 }
2623 }
2624
2625 writer.println(prefix + " Hotseat");
Sunny Goyal876e4622018-11-02 13:50:40 -07002626 ViewGroup layout = mHotseat.getShortcutsAndWidgets();
Sunny Goyala1365452015-10-01 15:46:24 -07002627 for (int j = 0; j < layout.getChildCount(); j++) {
2628 Object tag = layout.getChildAt(j).getTag();
2629 if (tag != null) {
2630 writer.println(prefix + " " + tag.toString());
2631 }
Adam Cohen4caf2982013-08-20 18:54:31 -07002632 }
Sunny Goyala1365452015-10-01 15:46:24 -07002633 }
2634
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08002635 writer.println(prefix + "Misc:");
Winson Chungef528762019-09-06 12:05:52 -07002636 dumpMisc(prefix + "\t", writer);
2637 writer.println(prefix + "\tmWorkspaceLoading=" + mWorkspaceLoading);
2638 writer.println(prefix + "\tmPendingRequestArgs=" + mPendingRequestArgs
2639 + " mPendingActivityResult=" + mPendingActivityResult);
2640 writer.println(prefix + "\tmRotationHelper: " + mRotationHelper);
2641 writer.println(prefix + "\tmAppWidgetHost.isListening: " + mAppWidgetHost.isListening());
2642
Tony Wickham646e4482020-04-06 17:25:53 -07002643 // Extra logging for general debugging
Hyunyoung Songa310a802019-04-25 13:57:16 -07002644 mDragLayer.dump(prefix, writer);
2645 mStateManager.dump(prefix, writer);
Tony Wickham646e4482020-04-06 17:25:53 -07002646 mPopupDataProvider.dump(prefix, writer);
Sunny Goyal2bba1902018-02-27 12:20:50 -08002647
2648 try {
2649 FileLog.flushAll(writer);
2650 } catch (Exception e) {
2651 // Ignore
2652 }
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08002653
2654 mModel.dumpState(prefix, fd, writer, args);
Sunny Goyala1365452015-10-01 15:46:24 -07002655
Adam Cohen9211d422014-10-07 18:14:53 -07002656 if (mLauncherCallbacks != null) {
2657 mLauncherCallbacks.dump(prefix, fd, writer, args);
2658 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -07002659 mOverlayManager.dump(prefix, writer);
Adam Cohen16d7ffc2011-10-05 17:49:14 -07002660 }
Adam Cohen487f7dd2012-06-28 18:12:10 -07002661
Sunny Goyal66b24572016-09-21 15:57:55 -07002662 @Override
Sunny Goyal66b24572016-09-21 15:57:55 -07002663 public void onProvideKeyboardShortcuts(
2664 List<KeyboardShortcutGroup> data, Menu menu, int deviceId) {
2665
2666 ArrayList<KeyboardShortcutInfo> shortcutInfos = new ArrayList<>();
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07002667 if (isInState(NORMAL)) {
Sunny Goyal66b24572016-09-21 15:57:55 -07002668 shortcutInfos.add(new KeyboardShortcutInfo(getString(R.string.all_apps_button_label),
2669 KeyEvent.KEYCODE_A, KeyEvent.META_CTRL_ON));
Vadim Tryshev74c261c2018-06-12 13:44:43 -07002670 shortcutInfos.add(new KeyboardShortcutInfo(getString(R.string.widget_button_text),
2671 KeyEvent.KEYCODE_W, KeyEvent.META_CTRL_ON));
Sunny Goyal66b24572016-09-21 15:57:55 -07002672 }
Sunny Goyal384b5782021-02-09 22:50:02 -08002673 getSupportedActions(this, getCurrentFocus()).forEach(la ->
Vadim Tryshev3455f8d2018-05-11 20:02:20 -07002674 shortcutInfos.add(new KeyboardShortcutInfo(
Sunny Goyal384b5782021-02-09 22:50:02 -08002675 la.accessibilityAction.getLabel(), la.keyCode, KeyEvent.META_CTRL_ON)));
Sunny Goyal66b24572016-09-21 15:57:55 -07002676 if (!shortcutInfos.isEmpty()) {
2677 data.add(new KeyboardShortcutGroup(getString(R.string.home_screen), shortcutInfos));
2678 }
2679
2680 super.onProvideKeyboardShortcuts(data, menu, deviceId);
2681 }
2682
2683 @Override
2684 public boolean onKeyShortcut(int keyCode, KeyEvent event) {
2685 if (event.hasModifiers(KeyEvent.META_CTRL_ON)) {
2686 switch (keyCode) {
2687 case KeyEvent.KEYCODE_A:
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07002688 if (isInState(NORMAL)) {
2689 getStateManager().goToState(ALL_APPS);
Sunny Goyal66b24572016-09-21 15:57:55 -07002690 return true;
2691 }
2692 break;
Vadim Tryshev74c261c2018-06-12 13:44:43 -07002693 case KeyEvent.KEYCODE_W:
2694 if (isInState(NORMAL)) {
2695 OptionsPopupView.openWidgets(this);
2696 return true;
2697 }
2698 break;
Sunny Goyal384b5782021-02-09 22:50:02 -08002699 default:
2700 for (LauncherAction la : getSupportedActions(this, getCurrentFocus())) {
2701 if (la.keyCode == keyCode) {
2702 return la.invokeFromKeyboard(getCurrentFocus());
2703 }
2704 }
Sunny Goyal66b24572016-09-21 15:57:55 -07002705 }
2706 }
2707 return super.onKeyShortcut(keyCode, event);
2708 }
2709
Vadim Tryshev646a0dd2018-02-05 16:27:50 -08002710 @Override
2711 public boolean onKeyUp(int keyCode, KeyEvent event) {
2712 if (keyCode == KeyEvent.KEYCODE_MENU) {
2713 // KEYCODE_MENU is sent by some tests, for example
2714 // LauncherJankTests#testWidgetsContainerFling. Don't just remove its handling.
2715 if (!mDragController.isDragging() && !mWorkspace.isSwitchingState() &&
2716 isInState(NORMAL)) {
2717 // Close any open floating views.
Andy Wickham65ced1b2020-03-07 02:14:19 +00002718 closeOpenViews();
Vadim Tryshev646a0dd2018-02-05 16:27:50 -08002719
2720 // Setting the touch point to (-1, -1) will show the options popup in the center of
2721 // the screen.
vadimtbc5d7e62019-12-09 13:53:05 -08002722 if (Utilities.IS_RUNNING_IN_TEST_HARNESS) {
2723 Log.d(TestProtocol.PERMANENT_DIAG_TAG, "Opening options popup on key up");
2724 }
Sunny Goyal2fd7a8b2018-03-30 17:10:13 -07002725 OptionsPopupView.showDefaultOptions(this, -1, -1);
Vadim Tryshev646a0dd2018-02-05 16:27:50 -08002726 }
2727 return true;
2728 }
2729 return super.onKeyUp(keyCode, event);
2730 }
2731
Sunny Goyalb5181c82021-03-10 07:39:12 +00002732 @Override
2733 protected void collectStateHandlers(List<StateHandler> out) {
2734 out.add(getAllAppsController());
2735 out.add(getWorkspace());
Andrew Sappersteinabef55a2016-06-19 12:49:00 -07002736 }
2737
Sunny Goyal210e1742019-10-17 12:05:38 -07002738 public TouchController[] createTouchControllers() {
2739 return new TouchController[] {getDragController(), new AllAppsSwipeController(this)};
2740 }
2741
Sunny Goyal210e1742019-10-17 12:05:38 -07002742 public void useFadeOutAnimationForLauncherStart(CancellationSignal signal) { }
2743
2744 public void onDragLayerHierarchyChanged() { }
2745
Vinit Nayakf9b585b2019-07-10 14:25:32 -07002746 @Override
2747 public void returnToHomescreen() {
2748 super.returnToHomescreen();
2749 getStateManager().goToState(LauncherState.NORMAL);
2750 }
2751
Andy Wickham65ced1b2020-03-07 02:14:19 +00002752 private void closeOpenViews() {
2753 closeOpenViews(true);
2754 }
2755
2756 protected void closeOpenViews(boolean animate) {
2757 AbstractFloatingView.closeAllOpenViews(this, animate);
2758 }
2759
Sunny Goyal3a1eadd2019-10-23 17:44:27 -07002760 public Stream<SystemShortcut.Factory> getSupportedShortcuts() {
Samuel Fufa5cf3e862020-02-03 20:22:54 -08002761 return Stream.of(APP_INFO, WIDGETS, INSTALL);
Sunny Goyal3a1eadd2019-10-23 17:44:27 -07002762 }
2763
Sunny Goyal384b5782021-02-09 22:50:02 -08002764 protected LauncherAccessibilityDelegate createAccessibilityDelegate() {
2765 return new LauncherAccessibilityDelegate(this);
2766 }
Sunny Goyalf2393f12020-04-01 20:13:12 -07002767
2768 /**
2769 * @see LauncherState#getOverviewScaleAndOffset(Launcher)
2770 */
2771 public float[] getNormalOverviewScaleAndOffset() {
2772 return new float[] {NO_SCALE, NO_OFFSET};
2773 }
2774
Sunny Goyal210e1742019-10-17 12:05:38 -07002775 public static Launcher getLauncher(Context context) {
Winson Chung8687bc22020-02-27 23:34:24 -08002776 return fromContext(context);
Sunny Goyal210e1742019-10-17 12:05:38 -07002777 }
2778
Sunny Goyal3dce5f32017-10-05 11:40:05 -07002779 /**
Sunny Goyalab770a12018-11-14 15:17:26 -08002780 * Just a wrapper around the type cast to allow easier tracking of calls.
2781 */
2782 public static <T extends Launcher> T cast(ActivityContext activityContext) {
2783 return (T) activityContext;
2784 }
2785
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -07002786 /**
2787 * Cross-fades the launcher's updated appearance with its previous appearance.
2788 *
2789 * This method is used to cross-fade UI updates on activity creation, specifically dark mode
2790 * updates.
2791 */
2792 private void crossFadeWithPreviousAppearance() {
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08002793 NonConfigInstance lastInstance = (NonConfigInstance) getLastNonConfigurationInstance();
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -07002794
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08002795 if (lastInstance == null || lastInstance.snapshot == null) {
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -07002796 return;
2797 }
2798
2799 ImageView crossFadeHelper = new ImageView(this);
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08002800 crossFadeHelper.setImageBitmap(lastInstance.snapshot);
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -07002801 crossFadeHelper.setImportantForAccessibility(IMPORTANT_FOR_ACCESSIBILITY_NO);
2802
2803 InsettableFrameLayout.LayoutParams layoutParams = new InsettableFrameLayout.LayoutParams(
2804 InsettableFrameLayout.LayoutParams.MATCH_PARENT,
2805 InsettableFrameLayout.LayoutParams.MATCH_PARENT);
2806
2807 layoutParams.ignoreInsets = true;
2808
2809 crossFadeHelper.setLayoutParams(layoutParams);
2810
2811 getRootView().addView(crossFadeHelper);
2812
2813 crossFadeHelper
2814 .animate()
2815 .setDuration(THEME_CROSS_FADE_ANIMATION_DURATION)
2816 .alpha(0f)
2817 .withEndAction(() -> getRootView().removeView(crossFadeHelper))
2818 .start();
2819 }
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08002820
Tony Wickham794fe4f2021-01-11 14:54:23 -06002821 /**
2822 * @return Whether the View is in the same window as the Taskbar window.
2823 */
2824 public boolean isViewInTaskbar(View v) {
2825 return false;
2826 }
2827
Sunny Goyalb65d7662021-03-07 15:09:11 -08002828 public boolean supportsAdaptiveIconAnimation(View clickedView) {
2829 return false;
2830 }
2831
Tony Wickham39938cb2021-02-26 09:15:31 -08002832 public DragOptions getDefaultWorkspaceDragOptions() {
2833 return new DragOptions();
2834 }
2835
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08002836 private static class NonConfigInstance {
2837 public Configuration config;
2838 public Bitmap snapshot;
2839 }
thiruramc96873c2021-02-11 15:13:47 -08002840
2841 @Override
2842 public StatsLogManager getStatsLogManager() {
2843 return super.getStatsLogManager().withDefaultInstanceId(mAllAppsSessionLogId);
2844 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002845}