blob: 5c0fd47e10b8991e2f1e6b1e04e1a15a1a3b0a06 [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 Goyalcd2ac0f2022-04-14 21:21:47 -070019import static android.app.PendingIntent.FLAG_IMMUTABLE;
20import static android.app.PendingIntent.FLAG_UPDATE_CURRENT;
Sunny Goyal6c0c61a2020-12-08 19:19:56 -080021import static android.content.pm.ActivityInfo.CONFIG_UI_MODE;
Sunny Goyal8f965462020-04-23 19:00:36 -070022import static android.view.accessibility.AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED;
Vinit Nayak48b28022020-04-27 20:48:49 +000023
Pinyao Tinga74b63a2019-07-17 23:26:06 -070024import static com.android.launcher3.AbstractFloatingView.TYPE_ALL;
Brian Isganitisa85ae692021-09-23 19:56:24 -040025import static com.android.launcher3.AbstractFloatingView.TYPE_FOLDER;
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;
Brian Isganitisa85ae692021-09-23 19:56:24 -040029import static com.android.launcher3.AbstractFloatingView.getTopOpenViewWithType;
Alex Chau0c4e11b2022-07-08 18:41:36 +010030import static com.android.launcher3.LauncherAnimUtils.HOTSEAT_SCALE_PROPERTY_FACTORY;
31import static com.android.launcher3.LauncherAnimUtils.SCALE_INDEX_WIDGET_TRANSITION;
Sunny Goyal4c7f2152017-10-17 17:17:16 -070032import static com.android.launcher3.LauncherAnimUtils.SPRING_LOADED_EXIT_DELAY;
Alex Chau0c4e11b2022-07-08 18:41:36 +010033import static com.android.launcher3.LauncherAnimUtils.WORKSPACE_SCALE_PROPERTY_FACTORY;
Sunny Goyal669b71f2023-01-27 14:37:07 -080034import static com.android.launcher3.LauncherSettings.Favorites.CONTAINER_DESKTOP;
Jon Mirandac4a99bf2021-11-04 16:53:45 -070035import static com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_APPLICATION;
Sunny Goyal3e3f44c2017-10-23 17:14:52 -070036import static com.android.launcher3.LauncherState.ALL_APPS;
Sunny Goyal8f965462020-04-23 19:00:36 -070037import static com.android.launcher3.LauncherState.FLAG_MULTI_PAGE;
38import static com.android.launcher3.LauncherState.FLAG_NON_INTERACTIVE;
Sunny Goyal3e3f44c2017-10-23 17:14:52 -070039import static com.android.launcher3.LauncherState.NORMAL;
Sunny Goyalf2393f12020-04-01 20:13:12 -070040import static com.android.launcher3.LauncherState.NO_OFFSET;
41import static com.android.launcher3.LauncherState.NO_SCALE;
Sunny Goyal8f965462020-04-23 19:00:36 -070042import static com.android.launcher3.LauncherState.SPRING_LOADED;
Sunny Goyalb1d7de22019-09-06 10:36:54 -070043import static com.android.launcher3.Utilities.postAsyncCallback;
Sunny Goyal384b5782021-02-09 22:50:02 -080044import static com.android.launcher3.accessibility.LauncherAccessibilityDelegate.getSupportedActions;
Alex Chau3d2c0622022-09-01 21:28:14 +010045import static com.android.launcher3.anim.Interpolators.EMPHASIZED;
Sebastian Franco09589322022-11-02 15:25:58 -070046import static com.android.launcher3.config.FeatureFlags.FOLDABLE_SINGLE_PAGE;
Federico Barona1845112022-10-20 21:11:58 -070047import static com.android.launcher3.config.FeatureFlags.SHOW_DOT_PAGINATION;
Thiru Ramasamy5fbac632022-01-28 15:05:36 -080048import static com.android.launcher3.logging.StatsLogManager.EventEnum;
Hyunyoung Song801f81f2020-06-19 02:58:53 -070049import static com.android.launcher3.logging.StatsLogManager.LAUNCHER_STATE_BACKGROUND;
Hyunyoung Song95786e02020-09-15 00:34:10 -070050import static com.android.launcher3.logging.StatsLogManager.LAUNCHER_STATE_HOME;
thiruramc96873c2021-02-11 15:13:47 -080051import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ALLAPPS_ENTRY;
thiruram9f53d612021-02-24 10:54:01 -080052import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ALLAPPS_ENTRY_WITH_DEVICE_SEARCH;
thiruramc96873c2021-02-11 15:13:47 -080053import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ALLAPPS_EXIT;
Hyunyoung Song801f81f2020-06-19 02:58:53 -070054import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ONRESUME;
55import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ONSTOP;
Sunny Goyal82379182022-11-02 18:58:49 -070056import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_SWIPELEFT;
57import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_SWIPERIGHT;
Yogisha Dixit4ff5ee32021-05-04 14:58:34 +010058import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_WIDGET_RECONFIGURED;
Sunny Goyal60e68c92020-08-12 13:59:27 -070059import static com.android.launcher3.model.ItemInstallQueue.FLAG_ACTIVITY_PAUSED;
60import static com.android.launcher3.model.ItemInstallQueue.FLAG_DRAG_AND_DROP;
Sunny Goyal3a1eadd2019-10-23 17:44:27 -070061import static com.android.launcher3.popup.SystemShortcut.APP_INFO;
Sunny Goyal3a1eadd2019-10-23 17:44:27 -070062import static com.android.launcher3.popup.SystemShortcut.INSTALL;
63import static com.android.launcher3.popup.SystemShortcut.WIDGETS;
Sunny Goyal8f965462020-04-23 19:00:36 -070064import static com.android.launcher3.states.RotationHelper.REQUEST_LOCK;
Sunny Goyalbe8c3402019-05-22 15:17:52 -070065import static com.android.launcher3.states.RotationHelper.REQUEST_NONE;
Jon Mirandac4a99bf2021-11-04 16:53:45 -070066import static com.android.launcher3.util.ItemInfoMatcher.forFolderMatch;
Sunny Goyal326403e2017-10-02 12:45:10 -070067
Gilles Debunnedd6c9922010-10-25 11:23:41 -070068import android.animation.Animator;
Sunny Goyal6001ea22018-05-10 16:31:00 -070069import android.animation.AnimatorListenerAdapter;
Gilles Debunnedd6c9922010-10-25 11:23:41 -070070import android.animation.AnimatorSet;
Gilles Debunnedd6c9922010-10-25 11:23:41 -070071import android.animation.ValueAnimator;
Adam Cohen0b395352014-06-09 22:54:36 +000072import android.annotation.TargetApi;
Tony Wickhame78a70b2021-03-29 16:45:59 -070073import android.app.Notification;
74import android.app.NotificationChannel;
75import android.app.NotificationManager;
76import android.app.PendingIntent;
Adam Cohen0cf2a7c2011-11-08 15:07:01 -080077import android.appwidget.AppWidgetHostView;
Michael Jurkaaf442092010-06-10 17:01:57 -070078import android.appwidget.AppWidgetManager;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080079import android.content.ActivityNotFoundException;
Michael Jurkae326f182011-11-21 14:05:46 -080080import android.content.ComponentCallbacks2;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080081import android.content.Context;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080082import android.content.Intent;
Adam Cohen173f7112015-03-27 15:14:00 -070083import android.content.IntentSender;
Winson Chung82f55532011-08-09 14:14:23 -070084import android.content.SharedPreferences;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080085import android.content.pm.PackageManager;
Sunny Goyalf8d56fc2018-01-31 15:18:11 -080086import android.content.res.Configuration;
Adam Cohen3f9c9712014-10-31 11:48:25 -070087import android.database.sqlite.SQLiteDatabase;
Tony Wickham1906cc32021-02-11 11:55:24 -080088import android.graphics.Rect;
Sunny Goyal831212e2021-05-14 14:24:09 -070089import android.graphics.RectF;
Adam Cohen0f668f32014-09-08 19:54:17 +020090import android.os.Build;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080091import android.os.Bundle;
Sunny Goyal210e1742019-10-17 12:05:38 -070092import android.os.CancellationSignal;
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -070093import android.os.Parcelable;
Sunny Goyal7c74e4a2016-12-15 15:53:17 -080094import android.os.Process;
Winson Chunga2413752012-04-03 14:22:34 -070095import android.os.StrictMode;
Riddle Hsu979da642020-09-22 21:52:40 +080096import android.os.SystemClock;
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -070097import android.os.Trace;
Jon Mirandac4a99bf2021-11-04 16:53:45 -070098import android.os.UserHandle;
Michael Jurkaa33411c2012-06-14 16:18:21 -070099import android.text.TextUtils;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800100import android.text.method.TextKeyListener;
Federico Baron7539d762022-09-29 09:47:04 -0700101import android.util.AttributeSet;
Alex Chau0c4e11b2022-07-08 18:41:36 +0100102import android.util.FloatProperty;
Joe Onorato7c312c12009-08-13 21:36:53 -0700103import android.util.Log;
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -0700104import android.util.SparseArray;
Adam Cohen96d30a12013-07-16 18:13:21 -0700105import android.view.KeyEvent;
Sunny Goyal66b24572016-09-21 15:57:55 -0700106import android.view.KeyboardShortcutGroup;
107import android.view.KeyboardShortcutInfo;
Sunny Goyal9b29ca52017-02-17 10:39:44 -0800108import android.view.LayoutInflater;
Adam Cohen96d30a12013-07-16 18:13:21 -0700109import android.view.Menu;
vadimt9af34a72020-01-21 11:19:13 -0800110import android.view.MotionEvent;
Adam Cohen96d30a12013-07-16 18:13:21 -0700111import android.view.View;
Adam Cohen96d30a12013-07-16 18:13:21 -0700112import android.view.ViewGroup;
Sunny Goyal7b8d63f2022-04-14 16:37:32 -0700113import android.view.ViewTreeObserver.OnPreDrawListener;
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -0700114import android.view.WindowManager.LayoutParams;
Svetoslav Ganov815ba2d2011-01-07 14:55:17 -0800115import android.view.accessibility.AccessibilityEvent;
Sunny Goyal5a1f53b2015-05-27 10:24:24 -0700116import android.view.animation.OvershootInterpolator;
Adam Cohen96d30a12013-07-16 18:13:21 -0700117import android.widget.Toast;
Sunny Goyala1d1bf32015-06-26 13:24:53 -0700118
Sunny Goyal35e7d382020-05-08 13:37:58 -0700119import androidx.annotation.CallSuper;
Fengjiang Lie884c2c2022-12-19 14:42:14 -0800120import androidx.annotation.FloatRange;
Andras Kloczl55edfe52021-05-14 12:21:30 +0200121import androidx.annotation.NonNull;
Sunny Goyal11a50742019-08-07 09:24:26 -0700122import androidx.annotation.Nullable;
Pinyao Tingc9074272019-11-11 11:51:44 -0800123import androidx.annotation.StringRes;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700124import androidx.annotation.VisibleForTesting;
Sunny Goyal11a50742019-08-07 09:24:26 -0700125
Sunny Goyal651077b2014-06-30 14:15:31 -0700126import com.android.launcher3.DropTarget.DragObject;
Schneider Victor-tuliasbdb0dd82021-11-03 16:26:41 -0700127import com.android.launcher3.accessibility.BaseAccessibilityDelegate.LauncherAction;
Sunny Goyalae502842016-06-17 08:43:56 -0700128import com.android.launcher3.accessibility.LauncherAccessibilityDelegate;
Brian Isganitis1664c9f2022-01-14 23:15:47 -0500129import com.android.launcher3.allapps.ActivityAllAppsContainerView;
Jon Mirandaf58db152022-06-02 16:06:37 -0700130import com.android.launcher3.allapps.AllAppsRecyclerView;
vadimtd4c90e12019-06-04 13:59:43 -0700131import com.android.launcher3.allapps.AllAppsStore;
Hyunyoung Song645764e2016-06-06 14:19:02 -0700132import com.android.launcher3.allapps.AllAppsTransitionController;
Becky Qiu4ed3dfc2022-10-19 16:58:22 -0700133import com.android.launcher3.allapps.BaseSearchConfig;
Sunny Goyal7ede6112017-12-05 15:11:21 -0800134import com.android.launcher3.allapps.DiscoveryBounce;
Sunny Goyalf0b6db72018-08-13 16:10:14 -0700135import com.android.launcher3.anim.PropertyListBuilder;
Sunny Goyal669b71f2023-01-27 14:37:07 -0800136import com.android.launcher3.celllayout.CellPosMapper;
137import com.android.launcher3.celllayout.CellPosMapper.CellPos;
Sebastian Franco09589322022-11-02 15:25:58 -0700138import com.android.launcher3.celllayout.CellPosMapper.TwoPanelCellPosMapper;
Sunny Goyal8f965462020-04-23 19:00:36 -0700139import com.android.launcher3.compat.AccessibilityManagerCompat;
Tony Wickhame0c33232016-02-08 11:37:04 -0800140import com.android.launcher3.config.FeatureFlags;
vadimt00d42552018-12-11 17:59:36 -0800141import com.android.launcher3.dot.DotInfo;
Vadim Tryshevfedca432015-08-19 17:55:02 -0700142import com.android.launcher3.dragndrop.DragController;
143import com.android.launcher3.dragndrop.DragLayer;
Tony Wickham39938cb2021-02-26 09:15:31 -0800144import com.android.launcher3.dragndrop.DragOptions;
Vadim Tryshevfedca432015-08-19 17:55:02 -0700145import com.android.launcher3.dragndrop.DragView;
Sunny Goyal59969372021-05-06 12:11:44 -0700146import com.android.launcher3.dragndrop.LauncherDragController;
Federico Baron8bf1bca2022-09-27 16:19:11 -0700147import com.android.launcher3.folder.Folder;
Sunny Goyal11a50742019-08-07 09:24:26 -0700148import com.android.launcher3.folder.FolderGridOrganizer;
Sunny Goyal26119432016-02-18 22:09:23 +0000149import com.android.launcher3.folder.FolderIcon;
Sunny Goyalf840f102018-09-21 14:41:05 -0700150import com.android.launcher3.icons.IconCache;
Sunny Goyal3333b0c2016-05-09 20:43:21 -0700151import com.android.launcher3.keyboard.ViewGroupFocusHelper;
Hyunyoung Song801f81f2020-06-19 02:58:53 -0700152import com.android.launcher3.logger.LauncherAtom;
Thiru Ramasamy5fbac632022-01-28 15:05:36 -0800153import com.android.launcher3.logger.LauncherAtom.ContainerInfo;
154import com.android.launcher3.logger.LauncherAtom.WorkspaceContainer;
Sunny Goyala7ce1662016-05-31 15:01:35 -0700155import com.android.launcher3.logging.FileLog;
thiruramc96873c2021-02-11 15:13:47 -0800156import com.android.launcher3.logging.InstanceId;
157import com.android.launcher3.logging.InstanceIdSequence;
Hyunyoung Song801f81f2020-06-19 02:58:53 -0700158import com.android.launcher3.logging.StatsLogManager;
Sunny Goyal87dcde62019-07-17 20:35:56 -0700159import com.android.launcher3.model.BgDataModel.Callbacks;
Sunny Goyal60e68c92020-08-12 13:59:27 -0700160import com.android.launcher3.model.ItemInstallQueue;
Sunny Goyal53116c62020-08-07 16:32:18 -0700161import com.android.launcher3.model.ModelUtils;
Sunny Goyala535ae42017-02-27 10:07:13 -0800162import com.android.launcher3.model.ModelWriter;
kholoud mohamedc76b2032021-12-20 16:47:38 +0000163import com.android.launcher3.model.StringCache;
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -0700164import com.android.launcher3.model.WidgetsModel;
Sunny Goyale396abf2020-04-06 15:11:17 -0700165import com.android.launcher3.model.data.AppInfo;
166import com.android.launcher3.model.data.FolderInfo;
167import com.android.launcher3.model.data.ItemInfo;
168import com.android.launcher3.model.data.LauncherAppWidgetInfo;
Sunny Goyale396abf2020-04-06 15:11:17 -0700169import com.android.launcher3.model.data.WorkspaceItemInfo;
Sunny Goyala535ae42017-02-27 10:07:13 -0800170import com.android.launcher3.notification.NotificationListener;
Federico Baron7539d762022-09-29 09:47:04 -0700171import com.android.launcher3.pageindicators.WorkspacePageIndicator;
Sunny Goyale7b00122019-10-02 16:13:34 -0700172import com.android.launcher3.pm.PinRequestHelper;
Samuel Fufa41d909f2020-03-20 16:27:09 -0700173import com.android.launcher3.pm.UserCache;
Brian Isganitis149dbcb2021-11-08 18:12:38 -0500174import com.android.launcher3.popup.ArrowPopup;
Tony Wickham540913e2017-01-23 11:47:51 -0800175import com.android.launcher3.popup.PopupContainerWithArrow;
Sunny Goyala535ae42017-02-27 10:07:13 -0800176import com.android.launcher3.popup.PopupDataProvider;
Sunny Goyal3a1eadd2019-10-23 17:44:27 -0700177import com.android.launcher3.popup.SystemShortcut;
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700178import com.android.launcher3.qsb.QsbContainerView;
Sunny Goyal35e7d382020-05-08 13:37:58 -0700179import com.android.launcher3.statemanager.StateManager;
180import com.android.launcher3.statemanager.StateManager.StateHandler;
Sunny Goyal35e7d382020-05-08 13:37:58 -0700181import com.android.launcher3.statemanager.StatefulActivity;
Sunny Goyal623eddd2018-03-02 12:24:41 -0800182import com.android.launcher3.states.RotationHelper;
vadimt9af34a72020-01-21 11:19:13 -0800183import com.android.launcher3.testing.TestLogging;
vadimtf6ef8792022-07-26 13:54:31 -0700184import com.android.launcher3.testing.shared.TestProtocol;
Sunny Goyal210e1742019-10-17 12:05:38 -0700185import com.android.launcher3.touch.AllAppsSwipeController;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700186import com.android.launcher3.uioverrides.plugins.PluginManagerWrapper;
Sunny Goyal2100c782016-08-22 16:00:03 -0700187import com.android.launcher3.util.ActivityResultInfo;
Sunny Goyale84c5b82019-09-26 17:05:31 -0700188import com.android.launcher3.util.ActivityTracker;
Winson Chung6b1c73f2015-06-18 11:38:42 -0700189import com.android.launcher3.util.ComponentKey;
Sunny Goyalefb7e842018-10-04 15:11:00 -0700190import com.android.launcher3.util.IntArray;
Andras Kloczl55edfe52021-05-14 12:21:30 +0200191import com.android.launcher3.util.IntSet;
Tony Wickham133cd542020-04-08 17:48:41 -0700192import com.android.launcher3.util.OnboardingPrefs;
Sunny Goyal04cc3a72016-05-17 10:32:43 -0700193import com.android.launcher3.util.PackageManagerHelper;
Tony Wickham010d2552017-01-20 08:15:28 -0800194import com.android.launcher3.util.PackageUserKey;
Sunny Goyal2100c782016-08-22 16:00:03 -0700195import com.android.launcher3.util.PendingRequestArgs;
Sunny Goyal4a48a982021-06-17 15:15:46 -0700196import com.android.launcher3.util.RunnableList;
Samuel Fufa41d909f2020-03-20 16:27:09 -0700197import com.android.launcher3.util.SafeCloseable;
Sunny Goyala992ac92023-01-10 17:50:32 -0800198import com.android.launcher3.util.ScreenOnTracker;
199import com.android.launcher3.util.ScreenOnTracker.ScreenOnListener;
Sunny Goyal8392c822017-06-20 10:03:56 -0700200import com.android.launcher3.util.SystemUiController;
Mario Bertschlera6936942017-05-31 14:48:19 -0700201import com.android.launcher3.util.Themes;
Adam Cohen091440a2015-03-18 14:16:05 -0700202import com.android.launcher3.util.Thunk;
Sunny Goyal210e1742019-10-17 12:05:38 -0700203import com.android.launcher3.util.TouchController;
Sunny Goyalfca6bc92017-09-28 16:28:34 -0700204import com.android.launcher3.util.TraceHelper;
Sunny Goyal527c7d32015-08-28 15:19:36 -0700205import com.android.launcher3.util.ViewOnDrawExecutor;
Sunny Goyalab770a12018-11-14 15:17:26 -0800206import com.android.launcher3.views.ActivityContext;
Jon Mirandaf58db152022-06-02 16:06:37 -0700207import com.android.launcher3.views.FloatingIconView;
Sunny Goyal30ac97d2020-06-24 23:47:46 -0700208import com.android.launcher3.views.FloatingSurfaceView;
Sunny Goyal7c7be8c2018-03-07 19:58:07 -0800209import com.android.launcher3.views.OptionsPopupView;
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400210import com.android.launcher3.views.ScrimView;
Sunny Goyal29947f02017-12-18 13:49:44 -0800211import com.android.launcher3.widget.LauncherAppWidgetHostView;
Yogisha Dixit741fae92021-02-22 14:03:44 +0000212import com.android.launcher3.widget.LauncherAppWidgetProviderInfo;
Sihua Ma8bbfcb62022-11-08 16:46:07 -0800213import com.android.launcher3.widget.LauncherWidgetHolder;
Sunny Goyal782f0c92017-01-19 10:27:54 -0800214import com.android.launcher3.widget.PendingAddShortcutInfo;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700215import com.android.launcher3.widget.PendingAddWidgetInfo;
Sunny Goyal29947f02017-12-18 13:49:44 -0800216import com.android.launcher3.widget.PendingAppWidgetHostView;
Sunny Goyal04a324a2017-01-20 21:08:59 -0800217import com.android.launcher3.widget.WidgetAddFlowHandler;
Sunny Goyal337c81f2019-12-10 12:19:13 -0800218import com.android.launcher3.widget.WidgetManagerHelper;
Pinyao Tingc7a6c292019-08-26 14:36:02 -0700219import com.android.launcher3.widget.custom.CustomWidgetManager;
Steven Ng2f5648a2021-02-08 17:18:25 +0000220import com.android.launcher3.widget.model.WidgetsListBaseEntry;
221import com.android.launcher3.widget.picker.WidgetsFullSheet;
Sunny Goyal80a071b2021-12-27 13:30:08 +0530222import com.android.systemui.plugins.LauncherOverlayPlugin;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700223import com.android.systemui.plugins.PluginListener;
224import com.android.systemui.plugins.shared.LauncherExterns;
225import com.android.systemui.plugins.shared.LauncherOverlayManager;
226import com.android.systemui.plugins.shared.LauncherOverlayManager.LauncherOverlay;
Adam Cohen6c5891a2014-07-09 23:53:15 -0700227
Adam Cohen16d7ffc2011-10-05 17:49:14 -0700228import java.io.FileDescriptor;
Adam Cohen16d7ffc2011-10-05 17:49:14 -0700229import java.io.PrintWriter;
Adam Cohenc0dcf592011-06-01 15:30:43 -0700230import java.util.ArrayList;
Winson Chungf0c6ae02012-03-21 16:10:31 -0700231import java.util.Collection;
Jon Mirandac4a99bf2021-11-04 16:53:45 -0700232import java.util.Collections;
Zak Cohen658c67a2018-10-19 14:21:05 -0700233import java.util.HashMap;
Sunny Goyal4390ace2014-10-13 11:33:11 -0700234import java.util.HashSet;
Michael Jurkad7c28052012-04-27 15:43:36 -0700235import java.util.List;
Thiru Ramasamy694407c2022-03-08 12:11:24 -0800236import java.util.Optional;
Sunny Goyalaae6fbb2019-01-31 16:05:58 -0800237import java.util.function.Predicate;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700238import java.util.function.Supplier;
Sunny Goyal3a1eadd2019-10-23 17:44:27 -0700239import java.util.stream.Stream;
Jon Mirandaf5197fc2019-09-04 16:55:41 -0700240
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800241/**
242 * Default launcher application.
243 */
Shikha Malhotra0f2e1b62022-03-27 21:02:21 +0000244public class Launcher extends StatefulActivity<LauncherState>
245 implements LauncherExterns, Callbacks, InvariantDeviceProfile.OnIDPChangeListener,
Sunny Goyal82379182022-11-02 18:58:49 -0700246 PluginListener<LauncherOverlayPlugin> {
Vadim Tryshevfedca432015-08-19 17:55:02 -0700247 public static final String TAG = "Launcher";
Sunny Goyale84c5b82019-09-26 17:05:31 -0700248
249 public static final ActivityTracker<Launcher> ACTIVITY_TRACKER = new ActivityTracker<>();
250
Sunny Goyal2bba4c32015-05-18 15:42:48 -0700251 static final boolean LOGD = false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800252
Winson Chunga2413752012-04-03 14:22:34 -0700253 static final boolean DEBUG_STRICT_MODE = false;
Romain Guy6fefcf12009-06-11 13:07:43 -0700254
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800255 private static final int REQUEST_CREATE_SHORTCUT = 1;
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700256 private static final int REQUEST_CREATE_APPWIDGET = 5;
Jon Mirandac476d6e2017-05-04 16:30:01 -0700257
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700258 private static final int REQUEST_PICK_APPWIDGET = 9;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800259
Michael Jurka8b805b12012-04-18 14:23:14 -0700260 private static final int REQUEST_BIND_APPWIDGET = 11;
Sunny Goyal8a2a63b2018-03-06 22:15:18 -0800261 public static final int REQUEST_BIND_PENDING_APPWIDGET = 12;
262 public static final int REQUEST_RECONFIGURE_APPWIDGET = 13;
Michael Jurka8b805b12012-04-18 14:23:14 -0700263
Jon Mirandac476d6e2017-05-04 16:30:01 -0700264 private static final int REQUEST_PERMISSION_CALL_PHONE = 14;
Sunny Goyal28c6b962015-10-12 11:42:05 -0700265
Sunny Goyal5a1f53b2015-05-27 10:24:24 -0700266 private static final float BOUNCE_ANIMATION_TENSION = 1.3f;
267
Mathew Inwood876a8462013-06-14 14:12:41 +0100268 /**
269 * IntentStarter uses request codes starting with this. This must be greater than all activity
270 * request codes used internally.
271 */
272 protected static final int REQUEST_LAST = 100;
273
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800274 // Type: int
Jeremy Simc94f4b72022-06-10 11:43:37 -0700275 protected static final String RUNTIME_STATE = "launcher.state";
Sunny Goyal2100c782016-08-22 16:00:03 -0700276 // Type: PendingRequestArgs
277 private static final String RUNTIME_STATE_PENDING_REQUEST_ARGS = "launcher.request_args";
Sunny Goyaldedda052019-05-14 15:23:48 -0700278 // Type: int
279 private static final String RUNTIME_STATE_PENDING_REQUEST_CODE = "launcher.request_code";
Sunny Goyal2100c782016-08-22 16:00:03 -0700280 // Type: ActivityResultInfo
281 private static final String RUNTIME_STATE_PENDING_ACTIVITY_RESULT = "launcher.activity_result";
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -0700282 // Type: SparseArray<Parcelable>
283 private static final String RUNTIME_STATE_WIDGET_PANEL = "launcher.widget_panel";
Sunny Goyal12e3f1f2021-07-15 14:31:58 -0700284 // Type int[]
285 private static final String RUNTIME_STATE_CURRENT_SCREEN_IDS = "launcher.current_screen_ids";
Sunny Goyal17c72fb2019-10-14 14:06:38 -0700286
Jeremy Simc94f4b72022-06-10 11:43:37 -0700287 // Type PendingSplitSelectInfo<Parcelable>
288 protected static final String PENDING_SPLIT_SELECT_INFO = "launcher.pending_split_select_info";
289
vadimt00d42552018-12-11 17:59:36 -0800290 public static final String ON_CREATE_EVT = "Launcher.onCreate";
Sunny Goyal17c72fb2019-10-14 14:06:38 -0700291 public static final String ON_START_EVT = "Launcher.onStart";
292 public static final String ON_RESUME_EVT = "Launcher.onResume";
293 public static final String ON_NEW_INTENT_EVT = "Launcher.onNewIntent";
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800294
Sunny Goyal35e7d382020-05-08 13:37:58 -0700295 private StateManager<LauncherState> mStateManager;
Patrick Dubroy6b509c12010-08-23 15:08:16 -0700296
Adam Cohenad4e15c2013-10-17 16:21:35 -0700297 private static final int ON_ACTIVITY_RESULT_ANIMATION_DELAY = 500;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800298
Winson Chunga2413752012-04-03 14:22:34 -0700299 // How long to wait before the new-shortcut animation automatically pans the workspace
Jon Mirandaf5197fc2019-09-04 16:55:41 -0700300 @VisibleForTesting public static final int NEW_APPS_PAGE_MOVE_DELAY = 500;
Rajeev Kumar43c0f582017-06-23 15:34:55 -0700301 private static final int NEW_APPS_ANIMATION_INACTIVE_TIMEOUT_SECONDS = 5;
Jon Mirandaf5197fc2019-09-04 16:55:41 -0700302 @Thunk @VisibleForTesting public static final int NEW_APPS_ANIMATION_DELAY = 500;
Winson Chunga2413752012-04-03 14:22:34 -0700303
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -0700304 private static final String DISPLAY_WORKSPACE_TRACE_METHOD_NAME = "DisplayWorkspaceFirstFrame";
305 private static final String DISPLAY_ALL_APPS_TRACE_METHOD_NAME = "DisplayAllApps";
306 public static final int DISPLAY_WORKSPACE_TRACE_COOKIE = 0;
307 public static final int DISPLAY_ALL_APPS_TRACE_COOKIE = 1;
308
Alex Chau0c4e11b2022-07-08 18:41:36 +0100309 private static final FloatProperty<Workspace<?>> WORKSPACE_WIDGET_SCALE =
310 WORKSPACE_SCALE_PROPERTY_FACTORY.get(SCALE_INDEX_WIDGET_TRANSITION);
311 private static final FloatProperty<Hotseat> HOTSEAT_WIDGET_SCALE =
312 HOTSEAT_SCALE_PROPERTY_FACTORY.get(SCALE_INDEX_WIDGET_TRANSITION);
313
Ats Jenk8121e0d2022-12-01 11:34:43 -0800314 private static final boolean DESKTOP_MODE_1_SUPPORTED =
315 "1".equals(Utilities.getSystemProperty("persist.wm.debug.desktop_mode", "0"));
316
317 private static final boolean DESKTOP_MODE_2_SUPPORTED =
318 "1".equals(Utilities.getSystemProperty("persist.wm.debug.desktop_mode_2", "0"));
319
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700320 @Thunk
Shikha Malhotra0f2e1b62022-03-27 21:02:21 +0000321 Workspace<?> mWorkspace;
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700322 @Thunk
323 DragLayer mDragLayer;
Sunny Goyal322d5562015-06-25 19:35:49 -0700324
Sunny Goyal337c81f2019-12-10 12:19:13 -0800325 private WidgetManagerHelper mAppWidgetManager;
Sihua Ma0593a0d2022-10-03 16:01:48 -0700326 private LauncherWidgetHolder mAppWidgetHolder;
Romain Guycbb89e42009-06-08 15:52:54 -0700327
Rajeev Kumar43c0f582017-06-23 15:34:55 -0700328 private final int[] mTmpAddItemCellCoordinates = new int[2];
Michael Jurka0280c3b2010-09-17 15:00:07 -0700329
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700330 @Thunk
331 Hotseat mHotseat;
Adam Cohenf358a4b2013-07-23 16:47:31 -0700332
Sunny Goyal47328fd2016-05-25 18:56:41 -0700333 private DropTargetBar mDropTargetBar;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700334
335 // Main container view for the all apps screen.
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700336 @Thunk
Brian Isganitis1664c9f2022-01-14 23:15:47 -0500337 ActivityAllAppsContainerView<Launcher> mAppsView;
Hyunyoung Song645764e2016-06-06 14:19:02 -0700338 AllAppsTransitionController mAllAppsController;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700339
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400340 // Scrim view for the all apps and overview state.
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700341 @Thunk
342 ScrimView mScrimView;
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400343
Winson Chung8ae41982017-11-10 11:42:13 -0800344 // UI and state for the overview panel
Sunny Goyal7c7be8c2018-03-07 19:58:07 -0800345 private View mOverviewPanel;
Winson Chung8ae41982017-11-10 11:42:13 -0800346
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700347 @Thunk
348 boolean mWorkspaceLoading = true;
Joe Onorato9c1289c2009-08-17 11:03:03 -0400349
Winson Chungc9bf6d42019-10-04 15:33:18 -0700350 // Used to notify when an activity launch has been deferred because launcher is not yet resumed
351 // TODO: See if we can remove this later
352 private Runnable mOnDeferredActivityLaunchCallback;
353
Sunny Goyal527c7d32015-08-28 15:19:36 -0700354 private ViewOnDrawExecutor mPendingExecutor;
Sunny Goyal7b8d63f2022-04-14 16:37:32 -0700355 private OnPreDrawListener mOnInitialBindListener;
Michael Jurka7607c2f2013-04-03 14:33:19 -0700356
Joe Onorato9c1289c2009-08-17 11:03:03 -0400357 private LauncherModel mModel;
Sunny Goyal43bf11d2017-02-02 13:52:53 -0800358 private ModelWriter mModelWriter;
Joe Onorato0589f0f2010-02-08 13:44:00 -0800359 private IconCache mIconCache;
Sunny Goyalae502842016-06-17 08:43:56 -0700360 private LauncherAccessibilityDelegate mAccessibilityDelegate;
Joe Onorato9c1289c2009-08-17 11:03:03 -0400361
Tony Wickham010d2552017-01-20 08:15:28 -0800362 private PopupDataProvider mPopupDataProvider;
Tony Wickhambfbf7f92016-05-19 11:19:39 -0700363
Andras Kloczl55edfe52021-05-14 12:21:30 +0200364 private IntSet mSynchronouslyBoundPages = new IntSet();
Sunny Goyal12e3f1f2021-07-15 14:31:58 -0700365 @NonNull private IntSet mPagesToBindSynchronously = new IntSet();
Adam Cohen1462de32012-07-24 22:34:36 -0700366
Winson Chung46353de2012-02-16 14:05:10 -0800367 // We only want to get the SharedPreferences once since it does an FS stat each time we get
368 // it from the context.
369 private SharedPreferences mSharedPrefs;
Brian Isganitis099945b2022-01-31 18:15:00 -0500370 private OnboardingPrefs<? extends Launcher> mOnboardingPrefs;
Winson Chung46353de2012-02-16 14:05:10 -0800371
Sunny Goyal2100c782016-08-22 16:00:03 -0700372 // Activity result which needs to be processed after workspace has loaded.
373 private ActivityResultInfo mPendingActivityResult;
374 /**
375 * Holds extra information required to handle a result from an external call, like
376 * {@link #startActivityForResult(Intent, int)} or {@link #requestPermissions(String[], int)}
377 */
378 private PendingRequestArgs mPendingRequestArgs;
Sunny Goyaldedda052019-05-14 15:23:48 -0700379 // Request id for any pending activity result
Sunny Goyal210e1742019-10-17 12:05:38 -0700380 protected int mPendingActivityRequestCode = -1;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800381
Tracy Zhou4d7b2442019-12-09 13:42:57 -0800382 private ViewGroupFocusHelper mFocusHandler;
Hyunyoung Song7fb3ccc2017-10-17 15:39:46 -0700383
Sunny Goyal623eddd2018-03-02 12:24:41 -0800384 private RotationHelper mRotationHelper;
Sunny Goyal7779d622015-06-11 16:18:39 -0700385
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700386 protected LauncherOverlayManager mOverlayManager;
Abhilasha Chahalcb329352022-05-31 15:50:53 +0000387 protected DragController mDragController;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700388 // If true, overlay callbacks are deferred
389 private boolean mDeferOverlayCallbacks;
390 private final Runnable mDeferredOverlayCallbacks = this::checkIfOverlayStillDeferred;
391
Riddle Hsu979da642020-09-22 21:52:40 +0800392 protected long mLastTouchUpTime = -1;
Sunny Goyala306e592020-03-24 01:51:41 -0700393 private boolean mTouchInProgress;
Sunny Goyal9b180102020-03-11 10:02:29 -0700394
Samuel Fufa41d909f2020-03-20 16:27:09 -0700395 private SafeCloseable mUserChangedCallbackCloseable;
396
thiruramc96873c2021-02-11 15:13:47 -0800397 // New InstanceId is assigned to mAllAppsSessionLogId for each AllApps sessions.
398 // When Launcher is not in AllApps state mAllAppsSessionLogId will be null.
399 // User actions within AllApps state are logged with this InstanceId, to recreate AllApps
400 // session on the server side.
401 protected InstanceId mAllAppsSessionLogId;
402 private LauncherState mPrevLauncherState;
403
kholoud mohamedc76b2032021-12-20 16:47:38 +0000404 private StringCache mStringCache;
Becky Qiu4ed3dfc2022-10-19 16:58:22 -0700405 private BaseSearchConfig mBaseSearchConfig;
kholoud mohamedc76b2032021-12-20 16:47:38 +0000406
Sunny Goyal669b71f2023-01-27 14:37:07 -0800407 private CellPosMapper mCellPosMapper = CellPosMapper.DEFAULT;
408
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800409 @Override
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -0700410 @TargetApi(Build.VERSION_CODES.S)
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800411 protected void onCreate(Bundle savedInstanceState) {
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -0700412 // Only use a hard-coded cookie since we only want to trace this once.
413 if (Utilities.ATLEAST_S) {
414 Trace.beginAsyncSection(
415 DISPLAY_WORKSPACE_TRACE_METHOD_NAME, DISPLAY_WORKSPACE_TRACE_COOKIE);
416 Trace.beginAsyncSection(DISPLAY_ALL_APPS_TRACE_METHOD_NAME,
417 DISPLAY_ALL_APPS_TRACE_COOKIE);
418 }
Winson Chung5cc62c72019-10-16 11:32:41 -0700419 Object traceToken = TraceHelper.INSTANCE.beginSection(ON_CREATE_EVT,
420 TraceHelper.FLAG_UI_EVENT);
Winson Chunga2413752012-04-03 14:22:34 -0700421 if (DEBUG_STRICT_MODE) {
422 StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
423 .detectDiskReads()
424 .detectDiskWrites()
425 .detectNetwork() // or .detectAll() for all detectable problems
426 .penaltyLog()
427 .build());
428 StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
429 .detectLeakedSqlLiteObjects()
430 .detectLeakedClosableObjects()
431 .penaltyLog()
432 .penaltyDeath()
433 .build());
434 }
435
Tony Wickhame78a70b2021-03-29 16:45:59 -0700436 if (Utilities.IS_DEBUG_DEVICE && FeatureFlags.NOTIFY_CRASHES.get()) {
437 final String notificationChannelId = "com.android.launcher3.Debug";
438 final String notificationChannelName = "Debug";
439 final String notificationTag = "Debug";
440 final int notificationId = 0;
441
442 NotificationManager notificationManager = getSystemService(NotificationManager.class);
443 notificationManager.createNotificationChannel(new NotificationChannel(
444 notificationChannelId, notificationChannelName,
445 NotificationManager.IMPORTANCE_HIGH));
446
447 Thread.currentThread().setUncaughtExceptionHandler((thread, throwable) -> {
448 String stackTrace = Log.getStackTraceString(throwable);
449
450 Intent shareIntent = new Intent(Intent.ACTION_SEND);
451 shareIntent.setType("text/plain");
452 shareIntent.putExtra(Intent.EXTRA_TEXT, stackTrace);
453 shareIntent = Intent.createChooser(shareIntent, null);
454 PendingIntent sharePendingIntent = PendingIntent.getActivity(
Sunny Goyalcd2ac0f2022-04-14 21:21:47 -0700455 this, 0, shareIntent, FLAG_UPDATE_CURRENT | FLAG_IMMUTABLE);
Tony Wickhame78a70b2021-03-29 16:45:59 -0700456
457 Notification notification = new Notification.Builder(this, notificationChannelId)
458 .setSmallIcon(android.R.drawable.ic_menu_close_clear_cancel)
459 .setContentTitle("Launcher crash detected!")
460 .setStyle(new Notification.BigTextStyle().bigText(stackTrace))
461 .addAction(android.R.drawable.ic_menu_share, "Share", sharePendingIntent)
462 .build();
463 notificationManager.notify(notificationTag, notificationId, notification);
464
465 Thread.UncaughtExceptionHandler defaultUncaughtExceptionHandler =
466 Thread.getDefaultUncaughtExceptionHandler();
467 if (defaultUncaughtExceptionHandler != null) {
468 defaultUncaughtExceptionHandler.uncaughtException(thread, throwable);
469 }
470 });
471 }
472
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800473 super.onCreate(savedInstanceState);
Daniel Sandlere060b0b2013-06-27 21:47:55 -0400474
Sunny Goyal87f784c2017-01-11 10:48:34 -0800475 LauncherAppState app = LauncherAppState.getInstance(this);
Sunny Goyala7a5bf32020-01-05 15:35:29 +0530476 mModel = app.getModel();
Sunny Goyal9d89f752020-06-19 11:09:24 -0700477
Sunny Goyal41d51a02019-05-14 09:44:34 -0700478 mRotationHelper = new RotationHelper(this);
Hyunyoung Song31971a32019-01-27 12:31:12 -0800479 InvariantDeviceProfile idp = app.getInvariantDeviceProfile();
480 initDeviceProfile(idp);
481 idp.addOnChangeListener(this);
Stefan Andonian146701c2022-11-10 23:07:40 +0000482 mSharedPrefs = LauncherPrefs.getPrefs(this);
Joe Onorato0589f0f2010-02-08 13:44:00 -0800483 mIconCache = app.getIconCache();
Sunny Goyal384b5782021-02-09 22:50:02 -0800484 mAccessibilityDelegate = createAccessibilityDelegate();
Adam Cohen2e6da152015-05-06 11:42:25 -0700485
Abhilasha Chahalcb329352022-05-31 15:50:53 +0000486 initDragController();
Hyunyoung Song645764e2016-06-06 14:19:02 -0700487 mAllAppsController = new AllAppsTransitionController(this);
Sunny Goyal35e7d382020-05-08 13:37:58 -0700488 mStateManager = new StateManager<>(this, NORMAL);
Romain Guycbb89e42009-06-08 15:52:54 -0700489
Sunny Goyal35e7d382020-05-08 13:37:58 -0700490 mOnboardingPrefs = createOnboardingPrefs(mSharedPrefs);
Tony Wickham133cd542020-04-08 17:48:41 -0700491
Luca Zuccarini81f5cee2022-10-11 13:02:09 +0000492 // TODO: move the SearchConfig to SearchState when new LauncherState is created.
493 mBaseSearchConfig = new BaseSearchConfig();
494
Sunny Goyal337c81f2019-12-10 12:19:13 -0800495 mAppWidgetManager = new WidgetManagerHelper(this);
Sihua Ma0593a0d2022-10-03 16:01:48 -0700496 mAppWidgetHolder = createAppWidgetHolder();
497 mAppWidgetHolder.startListening();
Romain Guycbb89e42009-06-08 15:52:54 -0700498
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800499 setupViews();
Sunny Goyal9c2b9602020-01-07 13:07:55 -0800500 mPopupDataProvider = new PopupDataProvider(this::updateNotificationDots);
Tony Wickham010d2552017-01-20 08:15:28 -0800501
Sunny Goyale84c5b82019-09-26 17:05:31 -0700502 boolean internalStateHandled = ACTIVITY_TRACKER.handleCreate(this);
Sunny Goyald3864fa2017-11-14 15:06:36 -0800503 if (internalStateHandled) {
Sunny Goyald3864fa2017-11-14 15:06:36 -0800504 if (savedInstanceState != null) {
505 // InternalStateHandler has already set the appropriate state.
506 // We dont need to do anything.
507 savedInstanceState.remove(RUNTIME_STATE);
508 }
509 }
510 restoreState(savedInstanceState);
Sunny Goyalbbece862019-03-01 13:13:52 -0800511 mStateManager.reapplyState();
Winson Chungb63b44c2017-11-10 17:54:44 -0800512
Sunny Goyalfe770c92016-09-27 14:38:58 -0700513 if (savedInstanceState != null) {
Sunny Goyal12e3f1f2021-07-15 14:31:58 -0700514 int[] pageIds = savedInstanceState.getIntArray(RUNTIME_STATE_CURRENT_SCREEN_IDS);
515 if (pageIds != null) {
516 mPagesToBindSynchronously = IntSet.wrap(pageIds);
517 }
Sunny Goyalfe770c92016-09-27 14:38:58 -0700518 }
Sunny Goyald3864fa2017-11-14 15:06:36 -0800519
Sunny Goyala7a5bf32020-01-05 15:35:29 +0530520 if (!mModel.addCallbacksAndLoad(this)) {
Sunny Goyald3864fa2017-11-14 15:06:36 -0800521 if (!internalStateHandled) {
Sunny Goyal7b8d63f2022-04-14 16:37:32 -0700522 // If we are not binding synchronously, pause drawing until initial bind complete,
523 // so that the system could continue to show the device loading prompt
524 mOnInitialBindListener = Boolean.FALSE::booleanValue;
Sunny Goyald3864fa2017-11-14 15:06:36 -0800525 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800526 }
527
528 // For handling default keys
Sunny Goyalf4aceab2017-12-06 16:16:31 -0800529 setDefaultKeyMode(DEFAULT_KEYS_SEARCH_LOCAL);
Joe Onorato34a0e1b2009-12-14 17:44:51 -0800530
Sunny Goyal9d89f752020-06-19 11:09:24 -0700531 setContentView(getRootView());
Sunny Goyal7b8d63f2022-04-14 16:37:32 -0700532 if (mOnInitialBindListener != null) {
533 getRootView().getViewTreeObserver().addOnPreDrawListener(mOnInitialBindListener);
534 }
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800535 getRootView().dispatchInsets();
Mario Bertschlera6936942017-05-31 14:48:19 -0700536
Sunny Goyala992ac92023-01-10 17:50:32 -0800537 // Listen for screen turning off
538 ScreenOnTracker.INSTANCE.get(this).addListener(mScreenOnListener);
Sunny Goyal8392c822017-06-20 10:03:56 -0700539 getSystemUiController().updateUiState(SystemUiController.UI_STATE_BASE_WINDOW,
540 Themes.getAttrBoolean(this, R.attr.isWorkspaceDarkText));
Sunny Goyal14b32402017-07-31 10:03:28 -0700541
542 if (mLauncherCallbacks != null) {
543 mLauncherCallbacks.onCreate(savedInstanceState);
544 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700545 mOverlayManager = getDefaultOverlay();
546 PluginManagerWrapper.INSTANCE.get(this).addPluginListener(this,
Sunny Goyal80a071b2021-12-27 13:30:08 +0530547 LauncherOverlayPlugin.class, false /* allowedMultiple */);
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700548
Sunny Goyal623eddd2018-03-02 12:24:41 -0800549 mRotationHelper.initialize();
Winson Chung5cc62c72019-10-16 11:32:41 -0700550 TraceHelper.INSTANCE.endSection(traceToken);
Samuel Fufa41d909f2020-03-20 16:27:09 -0700551
552 mUserChangedCallbackCloseable = UserCache.INSTANCE.get(this).addUserChangeListener(
553 () -> getStateManager().goToState(NORMAL));
Schneider Victor-tulias8a35c762020-09-03 14:30:10 -0700554
555 if (Utilities.ATLEAST_R) {
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -0700556 getWindow().setSoftInputMode(LayoutParams.SOFT_INPUT_ADJUST_NOTHING);
Schneider Victor-tulias8a35c762020-09-03 14:30:10 -0700557 }
Stefan Andonian45fc3012022-05-05 22:48:09 +0000558 setTitle(R.string.home_screen);
Adam Cohen9211d422014-10-07 18:14:53 -0700559 }
560
Fengjiang Li6bb8d792023-01-12 16:20:58 -0800561 /**
562 * Provide {@link OnBackPressedHandler} in below order:
563 * <ol>
564 * <li> auto cancel action mode handler
565 * <li> drag handler
566 * <li> view handler
567 * <li> state handler
568 * </ol>
569 *
570 * A back gesture (a single click on back button, or a swipe back gesture that contains a series
571 * of swipe events) should be handled by the same handler from above list. For a new back
572 * gesture, a new handler should be regenerated.
573 *
574 * Note that state handler will always be handling the back press event if the previous 3 don't.
575 */
576 @NonNull
577 protected OnBackPressedHandler getOnBackPressedHandler() {
578 // #1 auto cancel action mode handler
579 if (isInAutoCancelActionMode()) {
580 return this::finishAutoCancelActionMode;
581 }
582
583 // #2 drag handler
584 if (mDragController.isDragging()) {
585 return mDragController::cancelDrag;
586 }
587
588 // #3 view handler
589 AbstractFloatingView topView =
590 AbstractFloatingView.getTopOpenView(Launcher.this);
591 if (topView != null && topView.canHandleBack()) {
592 return topView;
593 }
594
595 // #4 state handler
596 return new OnBackPressedHandler() {
597 @Override
598 public void onBackInvoked() {
599 onStateBack();
600 }
601
602 @Override
603 public void onBackProgressed(
604 @FloatRange(from = 0.0, to = 1.0) float backProgress) {
605 mStateManager.getState().onBackProgressed(
606 Launcher.this, backProgress);
607 }
608
609 @Override
610 public void onBackCancelled() {
611 mStateManager.getState().onBackCancelled(Launcher.this);
612 }
613 };
614 }
615
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700616 protected LauncherOverlayManager getDefaultOverlay() {
617 return new LauncherOverlayManager() { };
618 }
619
Brian Isganitis099945b2022-01-31 18:15:00 -0500620 protected OnboardingPrefs<? extends Launcher> createOnboardingPrefs(
621 SharedPreferences sharedPrefs) {
Sunny Goyal35e7d382020-05-08 13:37:58 -0700622 return new OnboardingPrefs<>(this, sharedPrefs);
Tony Wickham133cd542020-04-08 17:48:41 -0700623 }
624
Brian Isganitis099945b2022-01-31 18:15:00 -0500625 public OnboardingPrefs<? extends Launcher> getOnboardingPrefs() {
Tony Wickham133cd542020-04-08 17:48:41 -0700626 return mOnboardingPrefs;
627 }
628
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700629 @Override
Sunny Goyal80a071b2021-12-27 13:30:08 +0530630 public void onPluginConnected(LauncherOverlayPlugin overlayManager, Context context) {
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700631 switchOverlay(() -> overlayManager.createOverlayManager(this, this));
632 }
633
634 @Override
Sunny Goyal80a071b2021-12-27 13:30:08 +0530635 public void onPluginDisconnected(LauncherOverlayPlugin plugin) {
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700636 switchOverlay(this::getDefaultOverlay);
637 }
638
639 private void switchOverlay(Supplier<LauncherOverlayManager> overlaySupplier) {
640 if (mOverlayManager != null) {
641 mOverlayManager.onActivityDestroyed(this);
642 }
643 mOverlayManager = overlaySupplier.get();
644 if (getRootView().isAttachedToWindow()) {
645 mOverlayManager.onAttachedToWindow();
646 }
647 mDeferOverlayCallbacks = true;
648 checkIfOverlayStillDeferred();
649 }
650
651 @Override
Brian Isganitis099945b2022-01-31 18:15:00 -0500652 public void dispatchDeviceProfileChanged() {
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700653 super.dispatchDeviceProfileChanged();
654 mOverlayManager.onDeviceProvideChanged();
655 }
656
Sunny Goyal7779d622015-06-11 16:18:39 -0700657 @Override
Winson Chung8eb49e02018-07-16 13:33:31 -0700658 public void onEnterAnimationComplete() {
659 super.onEnterAnimationComplete();
Sunny Goyalbe8c3402019-05-22 15:17:52 -0700660 mRotationHelper.setCurrentTransitionRequest(REQUEST_NONE);
Sunny Goyal5c20fdd2022-04-05 20:58:03 -0700661 // Starting with Android S, onEnterAnimationComplete is sent immediately
662 // causing the surface to get removed before the animation completed (b/175345344).
663 // Instead we rely on next user touch event to remove the view and optionally a callback
664 // from system from Android T onwards.
665 if (!Utilities.ATLEAST_S) {
666 AbstractFloatingView.closeOpenViews(this, false, TYPE_ICON_SURFACE);
667 }
Winson Chung8eb49e02018-07-16 13:33:31 -0700668 }
669
670 @Override
Jerry Chang09b40242021-08-27 13:29:01 +0800671 public void onMultiWindowModeChanged(boolean isInMultiWindowMode, Configuration newConfig) {
672 super.onMultiWindowModeChanged(isInMultiWindowMode, newConfig);
673 // Always update device profile when multi window mode changed.
674 initDeviceProfile(mDeviceProfile.inv);
675 dispatchDeviceProfileChanged();
676 }
677
Abhilasha Chahalcb329352022-05-31 15:50:53 +0000678 /**
679 * Initializes the drag controller.
680 */
681 protected void initDragController() {
682 mDragController = new LauncherDragController(this);
683 }
684
Sunny Goyal605bcf32018-03-02 15:16:12 -0800685 @Override
Sunny Goyal6e6f7992021-08-24 16:23:29 -0700686 public void onIdpChanged(boolean modelPropertiesChanged) {
Alex Chau360ec032022-08-10 16:11:42 +0100687 onHandleConfigurationChanged();
688 }
689
690 @Override
691 protected void onHandleConfigurationChanged() {
Alex Chau6209af62022-07-27 14:08:23 +0100692 if (!initDeviceProfile(mDeviceProfile.inv)) {
693 return;
694 }
695
Sunny Goyal371ea052019-03-06 15:38:32 -0800696 dispatchDeviceProfileChanged();
697 reapplyUi();
698 mDragLayer.recreateControllers();
699
Sunny Goyal76ba0a32019-06-10 11:56:11 -0700700 // Calling onSaveInstanceState ensures that static cache used by listWidgets is
701 // initialized properly.
702 onSaveInstanceState(new Bundle());
Sunny Goyalc4d32012020-04-03 17:10:11 -0700703 mModel.rebindCallbacks();
Hyunyoung Song31971a32019-01-27 12:31:12 -0800704 }
705
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400706 public void onAssistantVisibilityChanged(float visibility) {
Sunny Goyal0b5b8d42021-03-31 14:56:47 -0700707 mHotseat.getQsb().setAlpha(1f - visibility);
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400708 }
709
Bill Lina1221bc2021-06-03 01:49:27 +0800710 /**
Alex Chau6209af62022-07-27 14:08:23 +0100711 * Returns {@code true} if a new DeviceProfile is initialized, and {@code false} otherwise.
712 */
713 protected boolean initDeviceProfile(InvariantDeviceProfile idp) {
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800714 // Load configuration-specific DeviceProfile
Alex Chau6209af62022-07-27 14:08:23 +0100715 DeviceProfile deviceProfile = idp.getDeviceProfile(this);
716 if (mDeviceProfile == deviceProfile) {
717 return false;
718 }
719
720 mDeviceProfile = deviceProfile;
Jerry Changbfac46a2021-09-08 08:20:58 +0800721 if (isInMultiWindowMode()) {
722 mDeviceProfile = mDeviceProfile.getMultiWindowProfile(
723 this, getMultiWindowDisplaySize());
724 }
Sunny Goyalae6e3182019-04-30 12:04:37 -0700725
Sunny Goyal59d086c2018-05-07 17:31:40 -0700726 onDeviceProfileInitiated();
Sebastian Franco09589322022-11-02 15:25:58 -0700727 if (FOLDABLE_SINGLE_PAGE.get() && mDeviceProfile.isTwoPanels) {
728 mCellPosMapper = new TwoPanelCellPosMapper(mDeviceProfile.inv.numColumns);
729 } else {
730 mCellPosMapper = CellPosMapper.DEFAULT;
731 }
Sunny Goyal669b71f2023-01-27 14:37:07 -0800732 mModelWriter = mModel.getWriter(getDeviceProfile().isVerticalBarLayout(), true,
733 mCellPosMapper, this);
Alex Chau6209af62022-07-27 14:08:23 +0100734 return true;
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800735 }
736
Sunny Goyal669b71f2023-01-27 14:37:07 -0800737 @Override
738 public CellPosMapper getCellPosMapper() {
739 return mCellPosMapper;
740 }
741
Sunny Goyal623eddd2018-03-02 12:24:41 -0800742 public RotationHelper getRotationHelper() {
743 return mRotationHelper;
744 }
745
Tracy Zhou4d7b2442019-12-09 13:42:57 -0800746 public ViewGroupFocusHelper getFocusHandler() {
747 return mFocusHandler;
748 }
749
Sunny Goyal35e7d382020-05-08 13:37:58 -0700750 @Override
751 public StateManager<LauncherState> getStateManager() {
Sunny Goyal3e3f44c2017-10-23 17:14:52 -0700752 return mStateManager;
Sunny Goyalbe93f262017-10-20 17:05:27 -0700753 }
754
Adam Cohen9211d422014-10-07 18:14:53 -0700755 private LauncherCallbacks mLauncherCallbacks;
756
Sunny Goyal32554d12015-12-03 15:31:25 -0800757 /**
758 * Call this after onCreate to set or clear overlay.
759 */
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700760 @Override
Sunny Goyal32554d12015-12-03 15:31:25 -0800761 public void setLauncherOverlay(LauncherOverlay overlay) {
Sunny Goyal32554d12015-12-03 15:31:25 -0800762 mWorkspace.setLauncherOverlay(overlay);
763 }
764
Adam Cohen9211d422014-10-07 18:14:53 -0700765 public boolean setLauncherCallbacks(LauncherCallbacks callbacks) {
766 mLauncherCallbacks = callbacks;
767 return true;
Adam Cohenf9426d52012-06-04 17:26:21 -0700768 }
769
Hyunyoung Song3f471442015-04-08 19:01:34 -0700770 public boolean isDraggingEnabled() {
Winson Chung36a62fe2012-05-06 18:04:42 -0700771 // We prevent dragging when we are loading the workspace as it is possible to pick up a view
772 // that is subsequently removed from the workspace in startBinding().
Sunny Goyal639e9062015-08-19 19:17:06 -0700773 return !isWorkspaceLoading();
Winson Chung36a62fe2012-05-06 18:04:42 -0700774 }
775
Schneider Victor-tulias5173fd82021-10-19 14:47:23 -0700776 @NonNull
777 @Override
Tony Wickham010d2552017-01-20 08:15:28 -0800778 public PopupDataProvider getPopupDataProvider() {
779 return mPopupDataProvider;
780 }
781
Sunny Goyal0b0847b2018-03-14 12:30:11 -0700782 @Override
Tony Wickhamf34bee82018-12-03 18:11:39 -0800783 public DotInfo getDotInfoForItem(ItemInfo info) {
784 return mPopupDataProvider.getDotInfoForItem(info);
Sunny Goyal0b0847b2018-03-14 12:30:11 -0700785 }
786
787 @Override
788 public void invalidateParent(ItemInfo info) {
Jon Mirandae6f3fa42019-03-04 09:14:40 -0800789 if (info.container >= 0) {
Sunny Goyal0b0847b2018-03-14 12:30:11 -0700790 View folderIcon = getWorkspace().getHomescreenIconByItemId(info.container);
Jon Mirandae6f3fa42019-03-04 09:14:40 -0800791 if (folderIcon instanceof FolderIcon && folderIcon.getTag() instanceof FolderInfo) {
Sunny Goyal11a50742019-08-07 09:24:26 -0700792 if (new FolderGridOrganizer(getDeviceProfile().inv)
793 .setFolderInfo((FolderInfo) folderIcon.getTag())
794 .isItemInPreview(info.rank)) {
Jon Mirandae6f3fa42019-03-04 09:14:40 -0800795 folderIcon.invalidate();
796 }
Sunny Goyal0b0847b2018-03-14 12:30:11 -0700797 }
798 }
799 }
800
Adam Cohenc76e1dd2013-11-14 11:09:14 +0000801 /**
Winson Chung557d6ed2011-07-08 15:34:52 -0700802 * Returns whether we should delay spring loaded mode -- for shortcuts and widgets that have
803 * a configuration step, this allows the proper animations to run after other transitions.
804 */
Sunny Goyalefb7e842018-10-04 15:11:00 -0700805 private int completeAdd(
Sunny Goyal2100c782016-08-22 16:00:03 -0700806 int requestCode, Intent intent, int appWidgetId, PendingRequestArgs info) {
Sunny Goyal669b71f2023-01-27 14:37:07 -0800807 CellPos cellPos = getCellPosMapper().mapModelToPresenter(info);
808 int screenId = cellPos.screenId;
809 if (info.container == CONTAINER_DESKTOP) {
Adam Cohen83079e42014-09-19 17:43:08 -0700810 // When the screen id represents an actual screen (as opposed to a rank) we make sure
811 // that the drop page actually exists.
Sunny Goyal669b71f2023-01-27 14:37:07 -0800812 screenId = ensurePendingDropLayoutExists(cellPos.screenId);
Adam Cohen83079e42014-09-19 17:43:08 -0700813 }
Adam Cohendb364c32014-05-20 14:23:40 -0700814
Sunny Goyal2100c782016-08-22 16:00:03 -0700815 switch (requestCode) {
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800816 case REQUEST_CREATE_SHORTCUT:
Sunny Goyal669b71f2023-01-27 14:37:07 -0800817 completeAddShortcut(intent, info.container, screenId,
818 cellPos.cellX, cellPos.cellY, info);
Pinyao Tingc9074272019-11-11 11:51:44 -0800819 announceForAccessibility(R.string.item_added_to_workspace);
Winson Chungb8472bb2011-08-05 13:49:21 -0700820 break;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800821 case REQUEST_CREATE_APPWIDGET:
Sunny Goyal2100c782016-08-22 16:00:03 -0700822 completeAddAppWidget(appWidgetId, info, null, null);
Winson Chungb8472bb2011-08-05 13:49:21 -0700823 break;
Sunny Goyalff572272014-07-23 13:58:07 -0700824 case REQUEST_RECONFIGURE_APPWIDGET:
Sunny Goyal977838b2022-06-27 13:15:41 -0700825 getStatsLogManager().logger().withItemInfo(info).log(LAUNCHER_WIDGET_RECONFIGURED);
Sunny Goyal2100c782016-08-22 16:00:03 -0700826 completeRestoreAppWidget(appWidgetId, LauncherAppWidgetInfo.RESTORE_COMPLETED);
Sunny Goyalff572272014-07-23 13:58:07 -0700827 break;
Sunny Goyald478c832016-04-01 12:04:16 -0700828 case REQUEST_BIND_PENDING_APPWIDGET: {
Sunny Goyal2100c782016-08-22 16:00:03 -0700829 int widgetId = appWidgetId;
830 LauncherAppWidgetInfo widgetInfo =
Sunny Goyald478c832016-04-01 12:04:16 -0700831 completeRestoreAppWidget(widgetId, LauncherAppWidgetInfo.FLAG_UI_NOT_READY);
Sunny Goyal2100c782016-08-22 16:00:03 -0700832 if (widgetInfo != null) {
Sunny Goyald478c832016-04-01 12:04:16 -0700833 // Since the view was just bound, also launch the configure activity if needed
834 LauncherAppWidgetProviderInfo provider = mAppWidgetManager
835 .getLauncherAppWidgetInfo(widgetId);
Sunny Goyal04a324a2017-01-20 21:08:59 -0800836 if (provider != null) {
837 new WidgetAddFlowHandler(provider)
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700838 .startConfigActivity(this, widgetInfo,
839 REQUEST_RECONFIGURE_APPWIDGET);
Sunny Goyald478c832016-04-01 12:04:16 -0700840 }
841 }
842 break;
843 }
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800844 }
Adam Cohendb364c32014-05-20 14:23:40 -0700845 return screenId;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800846 }
847
Adam Cohenc7cd2cb2014-11-17 17:45:34 -0800848 private void handleActivityResult(
Michael Jurka8b805b12012-04-18 14:23:14 -0700849 final int requestCode, final int resultCode, final Intent data) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700850 if (isWorkspaceLoading()) {
851 // process the result once the workspace has loaded.
852 mPendingActivityResult = new ActivityResultInfo(requestCode, resultCode, data);
853 return;
854 }
855 mPendingActivityResult = null;
856
Winson Chunge341d302013-08-16 14:31:00 -0700857 // Reset the startActivity waiting flag
Sunny Goyal2100c782016-08-22 16:00:03 -0700858 final PendingRequestArgs requestArgs = mPendingRequestArgs;
859 setWaitingForResult(null);
860 if (requestArgs == null) {
861 return;
862 }
863
864 final int pendingAddWidgetId = requestArgs.getWidgetId();
Winson Chunge341d302013-08-16 14:31:00 -0700865
Adam Cohenad4e15c2013-10-17 16:21:35 -0700866 Runnable exitSpringLoaded = new Runnable() {
867 @Override
868 public void run() {
Sunny Goyal3e3f44c2017-10-23 17:14:52 -0700869 mStateManager.goToState(NORMAL, SPRING_LOADED_EXIT_DELAY);
Adam Cohenad4e15c2013-10-17 16:21:35 -0700870 }
871 };
872
Michael Jurka8b805b12012-04-18 14:23:14 -0700873 if (requestCode == REQUEST_BIND_APPWIDGET) {
Winsona1f79d32015-08-05 14:00:45 -0700874 // This is called only if the user did not previously have permissions to bind widgets
Adam Cohenad4e15c2013-10-17 16:21:35 -0700875 final int appWidgetId = data != null ?
Michael Jurka8b805b12012-04-18 14:23:14 -0700876 data.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1) : -1;
877 if (resultCode == RESULT_CANCELED) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700878 completeTwoStageWidgetDrop(RESULT_CANCELED, appWidgetId, requestArgs);
Sunny Goyal6e379fc2020-03-19 16:08:14 -0700879 mWorkspace.removeExtraEmptyScreenDelayed(
880 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false, exitSpringLoaded);
Michael Jurka8b805b12012-04-18 14:23:14 -0700881 } else if (resultCode == RESULT_OK) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700882 addAppWidgetImpl(
883 appWidgetId, requestArgs, null,
Sunny Goyal04a324a2017-01-20 21:08:59 -0800884 requestArgs.getWidgetHandler(),
Sunny Goyal2100c782016-08-22 16:00:03 -0700885 ON_ACTIVITY_RESULT_ANIMATION_DELAY);
Michael Jurka8b805b12012-04-18 14:23:14 -0700886 }
887 return;
888 }
Michael Jurka336fd4f2013-09-12 00:05:02 +0200889
Adam Cohened66b2b2012-01-23 17:28:51 -0800890 boolean isWidgetDrop = (requestCode == REQUEST_PICK_APPWIDGET ||
Sunny Goyal5c97f512015-05-19 16:03:28 -0700891 requestCode == REQUEST_CREATE_APPWIDGET);
Romain Guyaad5ef42009-06-10 02:48:37 -0700892
Adam Cohened66b2b2012-01-23 17:28:51 -0800893 // We have special handling for widgets
894 if (isWidgetDrop) {
Adam Cohen4637b5a2013-11-04 18:21:24 -0800895 final int appWidgetId;
896 int widgetId = data != null ? data.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1)
897 : -1;
898 if (widgetId < 0) {
899 appWidgetId = pendingAddWidgetId;
900 } else {
901 appWidgetId = widgetId;
902 }
903
Adam Cohenad4e15c2013-10-17 16:21:35 -0700904 final int result;
Adam Cohenf0129b12013-11-04 17:57:36 -0800905 if (appWidgetId < 0 || resultCode == RESULT_CANCELED) {
Adam Cohendb364c32014-05-20 14:23:40 -0700906 Log.e(TAG, "Error: appWidgetId (EXTRA_APPWIDGET_ID) was not " +
907 "returned from the widget configuration activity.");
Adam Cohenad4e15c2013-10-17 16:21:35 -0700908 result = RESULT_CANCELED;
Sunny Goyal2100c782016-08-22 16:00:03 -0700909 completeTwoStageWidgetDrop(result, appWidgetId, requestArgs);
Sunny Goyal6e379fc2020-03-19 16:08:14 -0700910 mWorkspace.removeExtraEmptyScreenDelayed(
911 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false,
912 () -> getStateManager().goToState(NORMAL));
Sunny Goyal2100c782016-08-22 16:00:03 -0700913 } else {
Sunny Goyal669b71f2023-01-27 14:37:07 -0800914 CellPos presenterPos = getCellPosMapper().mapModelToPresenter(requestArgs);
915 if (requestArgs.container == CONTAINER_DESKTOP) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700916 // When the screen id represents an actual screen (as opposed to a rank)
917 // we make sure that the drop page actually exists.
Sunny Goyal669b71f2023-01-27 14:37:07 -0800918 int newScreenId = ensurePendingDropLayoutExists(presenterPos.screenId);
919 requestArgs.screenId = getCellPosMapper().mapPresenterToModel(
920 presenterPos.cellX, presenterPos.cellY, newScreenId, CONTAINER_DESKTOP)
921 .screenId;
Adam Cohendb364c32014-05-20 14:23:40 -0700922 }
Sunny Goyal2100c782016-08-22 16:00:03 -0700923 final CellLayout dropLayout =
Sunny Goyal669b71f2023-01-27 14:37:07 -0800924 mWorkspace.getScreenWithId(presenterPos.screenId);
Sunny Goyal2100c782016-08-22 16:00:03 -0700925
926 dropLayout.setDropPending(true);
927 final Runnable onComplete = new Runnable() {
928 @Override
929 public void run() {
930 completeTwoStageWidgetDrop(resultCode, appWidgetId, requestArgs);
931 dropLayout.setDropPending(false);
932 }
933 };
Sunny Goyal6e379fc2020-03-19 16:08:14 -0700934 mWorkspace.removeExtraEmptyScreenDelayed(
935 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false, onComplete);
Winson Chung5aaab772012-04-27 15:24:02 -0700936 }
Adam Cohened66b2b2012-01-23 17:28:51 -0800937 return;
938 }
939
Sunny Goyald478c832016-04-01 12:04:16 -0700940 if (requestCode == REQUEST_RECONFIGURE_APPWIDGET
941 || requestCode == REQUEST_BIND_PENDING_APPWIDGET) {
Sunny Goyalff572272014-07-23 13:58:07 -0700942 if (resultCode == RESULT_OK) {
943 // Update the widget view.
Sunny Goyal2100c782016-08-22 16:00:03 -0700944 completeAdd(requestCode, data, pendingAddWidgetId, requestArgs);
Sunny Goyalff572272014-07-23 13:58:07 -0700945 }
946 // Leave the widget in the pending state if the user canceled the configure.
947 return;
948 }
949
Sunny Goyalaad90582015-07-09 14:22:50 -0700950 if (requestCode == REQUEST_CREATE_SHORTCUT) {
951 // Handle custom shortcuts created using ACTION_CREATE_SHORTCUT.
Sunny Goyal2100c782016-08-22 16:00:03 -0700952 if (resultCode == RESULT_OK && requestArgs.container != ItemInfo.NO_ID) {
953 completeAdd(requestCode, data, -1, requestArgs);
Sunny Goyal6e379fc2020-03-19 16:08:14 -0700954 mWorkspace.removeExtraEmptyScreenDelayed(
955 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false, exitSpringLoaded);
Sunny Goyal2100c782016-08-22 16:00:03 -0700956
Sunny Goyalaad90582015-07-09 14:22:50 -0700957 } else if (resultCode == RESULT_CANCELED) {
Sunny Goyal6e379fc2020-03-19 16:08:14 -0700958 mWorkspace.removeExtraEmptyScreenDelayed(
959 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false, exitSpringLoaded);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800960 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800961 }
Hongming Jind91cb6e2020-01-27 16:23:03 -0800962
Adam Cohened66b2b2012-01-23 17:28:51 -0800963 mDragLayer.clearAnimatedView();
Adam Cohenc7cd2cb2014-11-17 17:45:34 -0800964 }
965
966 @Override
Sunny Goyal64a75aa2017-07-03 13:50:52 -0700967 public void onActivityResult(
Adam Cohenc7cd2cb2014-11-17 17:45:34 -0800968 final int requestCode, final int resultCode, final Intent data) {
Sunny Goyaldedda052019-05-14 15:23:48 -0700969 mPendingActivityRequestCode = -1;
Adam Cohenc7cd2cb2014-11-17 17:45:34 -0800970 handleActivityResult(requestCode, resultCode, data);
Adam Cohened66b2b2012-01-23 17:28:51 -0800971 }
972
Sunny Goyal7ce471b2017-08-02 03:37:39 -0700973 @Override
Sunny Goyaldd2e6df2015-07-07 10:57:57 -0700974 public void onRequestPermissionsResult(int requestCode, String[] permissions,
Dave Hawkey3a43ed62015-06-26 10:27:47 -0600975 int[] grantResults) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700976 PendingRequestArgs pendingArgs = mPendingRequestArgs;
977 if (requestCode == REQUEST_PERMISSION_CALL_PHONE && pendingArgs != null
978 && pendingArgs.getRequestCode() == REQUEST_PERMISSION_CALL_PHONE) {
979 setWaitingForResult(null);
980
Sunny Goyal28c6b962015-10-12 11:42:05 -0700981 View v = null;
Sunny Goyal669b71f2023-01-27 14:37:07 -0800982 CellPos cellPos = getCellPosMapper().mapModelToPresenter(pendingArgs);
983 CellLayout layout = getCellLayout(pendingArgs.container, cellPos.screenId);
Sunny Goyal28c6b962015-10-12 11:42:05 -0700984 if (layout != null) {
Sunny Goyal669b71f2023-01-27 14:37:07 -0800985 v = layout.getChildAt(cellPos.cellX, cellPos.cellY);
Sunny Goyal28c6b962015-10-12 11:42:05 -0700986 }
Sunny Goyal2100c782016-08-22 16:00:03 -0700987 Intent intent = pendingArgs.getPendingIntent();
988
Sunny Goyal28c6b962015-10-12 11:42:05 -0700989 if (grantResults.length > 0
990 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
Sunny Goyal852537f2020-07-15 17:02:16 -0700991 startActivitySafely(v, intent, null);
Sunny Goyal28c6b962015-10-12 11:42:05 -0700992 } else {
993 // TODO: Show a snack bar with link to settings
994 Toast.makeText(this, getString(R.string.msg_no_phone_permission,
Sunny Goyal112ce422016-08-22 16:45:29 -0700995 getString(R.string.derived_app_name)), Toast.LENGTH_SHORT).show();
Sunny Goyal28c6b962015-10-12 11:42:05 -0700996 }
997 }
Dave Hawkey3a43ed62015-06-26 10:27:47 -0600998 }
999
Adam Cohendb364c32014-05-20 14:23:40 -07001000 /**
1001 * Check to see if a given screen id exists. If not, create it at the end, return the new id.
1002 *
1003 * @param screenId the screen id to check
1004 * @return the new screen, or screenId if it exists
1005 */
Sunny Goyalefb7e842018-10-04 15:11:00 -07001006 private int ensurePendingDropLayoutExists(int screenId) {
Sunny Goyal32554d12015-12-03 15:31:25 -08001007 CellLayout dropLayout = mWorkspace.getScreenWithId(screenId);
Adam Cohendb364c32014-05-20 14:23:40 -07001008 if (dropLayout == null) {
1009 // it's possible that the add screen was removed because it was
1010 // empty and a re-bind occurred
Andras Kloczl408a54f2021-08-28 00:59:08 +01001011 mWorkspace.addExtraEmptyScreens();
1012 IntSet emptyPagesAdded = mWorkspace.commitExtraEmptyScreens();
1013 return emptyPagesAdded.isEmpty() ? -1 : emptyPagesAdded.getArray().get(0);
Adam Cohendb364c32014-05-20 14:23:40 -07001014 }
Andras Kloczl408a54f2021-08-28 00:59:08 +01001015 return screenId;
Adam Cohendb364c32014-05-20 14:23:40 -07001016 }
1017
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001018 @Thunk
1019 void completeTwoStageWidgetDrop(
Sunny Goyal2100c782016-08-22 16:00:03 -07001020 final int resultCode, final int appWidgetId, final PendingRequestArgs requestArgs) {
Sunny Goyal669b71f2023-01-27 14:37:07 -08001021 CellLayout cellLayout = mWorkspace.getScreenWithId(
1022 getCellPosMapper().mapModelToPresenter(requestArgs).screenId);
Adam Cohened66b2b2012-01-23 17:28:51 -08001023 Runnable onCompleteRunnable = null;
1024 int animationType = 0;
1025
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001026 AppWidgetHostView boundWidget = null;
Adam Cohened66b2b2012-01-23 17:28:51 -08001027 if (resultCode == RESULT_OK) {
1028 animationType = Workspace.COMPLETE_TWO_STAGE_WIDGET_DROP_ANIMATION;
Sihua Ma0593a0d2022-10-03 16:01:48 -07001029 final AppWidgetHostView layout = mAppWidgetHolder.createView(this, appWidgetId,
Sunny Goyal04a324a2017-01-20 21:08:59 -08001030 requestArgs.getWidgetHandler().getProviderInfo(this));
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001031 boundWidget = layout;
Adam Cohened66b2b2012-01-23 17:28:51 -08001032 onCompleteRunnable = new Runnable() {
1033 @Override
1034 public void run() {
Sunny Goyal2100c782016-08-22 16:00:03 -07001035 completeAddAppWidget(appWidgetId, requestArgs, layout, null);
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001036 mStateManager.goToState(NORMAL, SPRING_LOADED_EXIT_DELAY);
Adam Cohened66b2b2012-01-23 17:28:51 -08001037 }
1038 };
1039 } else if (resultCode == RESULT_CANCELED) {
Sihua Ma0593a0d2022-10-03 16:01:48 -07001040 mAppWidgetHolder.deleteAppWidgetId(appWidgetId);
Adam Cohened66b2b2012-01-23 17:28:51 -08001041 animationType = Workspace.CANCEL_TWO_STAGE_WIDGET_DROP_ANIMATION;
Adam Cohened66b2b2012-01-23 17:28:51 -08001042 }
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001043 if (mDragLayer.getAnimatedView() != null) {
Sunny Goyal2100c782016-08-22 16:00:03 -07001044 mWorkspace.animateWidgetDrop(requestArgs, cellLayout,
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001045 (DragView) mDragLayer.getAnimatedView(), onCompleteRunnable,
1046 animationType, boundWidget, true);
Adam Cohenad4e15c2013-10-17 16:21:35 -07001047 } else if (onCompleteRunnable != null) {
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001048 // The animated view may be null in the case of a rotation during widget configuration
1049 onCompleteRunnable.run();
1050 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001051 }
1052
1053 @Override
Michael Jurkacd496d72013-04-11 11:32:45 -07001054 protected void onStop() {
1055 super.onStop();
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001056 if (mDeferOverlayCallbacks) {
1057 checkIfOverlayStillDeferred();
1058 } else {
1059 mOverlayManager.onActivityStopped(this);
Adam Cohen9211d422014-10-07 18:14:53 -07001060 }
Hyunyoung Song5ee7c132021-05-11 13:52:36 -07001061 hideKeyboard();
Hyunyoung Song95786e02020-09-15 00:34:10 -07001062 logStopAndResume(false /* isResume */);
Sihua Ma0593a0d2022-10-03 16:01:48 -07001063 mAppWidgetHolder.setActivityStarted(false);
Schneider Victor-tulias5173fd82021-10-19 14:47:23 -07001064 NotificationListener.removeNotificationsChangedListener(getPopupDataProvider());
Michael Jurkacd496d72013-04-11 11:32:45 -07001065 }
1066
1067 @Override
1068 protected void onStart() {
Winson Chung5cc62c72019-10-16 11:32:41 -07001069 Object traceToken = TraceHelper.INSTANCE.beginSection(ON_START_EVT,
1070 TraceHelper.FLAG_UI_EVENT);
Michael Jurkacd496d72013-04-11 11:32:45 -07001071 super.onStart();
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001072 if (!mDeferOverlayCallbacks) {
1073 mOverlayManager.onActivityStarted(this);
Adam Cohen9211d422014-10-07 18:14:53 -07001074 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001075
Sihua Ma0593a0d2022-10-03 16:01:48 -07001076 mAppWidgetHolder.setActivityStarted(true);
Winson Chung5cc62c72019-10-16 11:32:41 -07001077 TraceHelper.INSTANCE.endSection(traceToken);
Michael Jurkacd496d72013-04-11 11:32:45 -07001078 }
1079
Sunny Goyal35e7d382020-05-08 13:37:58 -07001080 @Override
1081 @CallSuper
1082 protected void onDeferredResumed() {
Hyunyoung Song95786e02020-09-15 00:34:10 -07001083 logStopAndResume(true /* isResume */);
Sunny Goyala002c6c2019-02-12 16:20:10 -08001084
Sunny Goyal35e7d382020-05-08 13:37:58 -07001085 // Process any items that were added while Launcher was away.
Sunny Goyal60e68c92020-08-12 13:59:27 -07001086 ItemInstallQueue.INSTANCE.get(this)
1087 .resumeModelPush(FLAG_ACTIVITY_PAUSED);
Sunny Goyale9c6f4c2019-05-30 11:35:25 -07001088
Sunny Goyal35e7d382020-05-08 13:37:58 -07001089 // Refresh shortcuts if the permission changed.
Sunny Goyal8b74cc72020-07-27 17:50:33 -07001090 mModel.validateModelDataOnResume();
Sunny Goyale9c6f4c2019-05-30 11:35:25 -07001091
Sunny Goyal35e7d382020-05-08 13:37:58 -07001092 // Set the notification listener and fetch updated notifications when we resume
Schneider Victor-tulias5173fd82021-10-19 14:47:23 -07001093 NotificationListener.addNotificationsChangedListener(mPopupDataProvider);
Winson Chung87583112019-06-10 14:20:58 -07001094
Sunny Goyal35e7d382020-05-08 13:37:58 -07001095 DiscoveryBounce.showForHomeIfNeeded(this);
Sihua Ma0593a0d2022-10-03 16:01:48 -07001096 mAppWidgetHolder.setActivityResumed(true);
Sunny Goyaldedda052019-05-14 15:23:48 -07001097 }
1098
Hyunyoung Song95786e02020-09-15 00:34:10 -07001099 private void logStopAndResume(boolean isResume) {
Hyunyoung Song77e29772020-08-25 00:53:48 -07001100 if (mPendingExecutor != null) return;
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001101 int pageIndex = mWorkspace.isOverlayShown() ? -1 : mWorkspace.getCurrentPage();
Hyunyoung Song95786e02020-09-15 00:34:10 -07001102 int statsLogOrdinal = mStateManager.getState().statsLogOrdinal;
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001103
1104 StatsLogManager.EventEnum event;
1105 StatsLogManager.StatsLogger logger = getStatsLogManager().logger();
Hyunyoung Song95786e02020-09-15 00:34:10 -07001106 if (isResume) {
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001107 logger.withSrcState(LAUNCHER_STATE_BACKGROUND)
Hyunyoung Song95786e02020-09-15 00:34:10 -07001108 .withDstState(mStateManager.getState().statsLogOrdinal);
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001109 event = LAUNCHER_ONRESUME;
1110 } else { /* command == Action.Command.STOP */
Hyunyoung Song95786e02020-09-15 00:34:10 -07001111 logger.withSrcState(mStateManager.getState().statsLogOrdinal)
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001112 .withDstState(LAUNCHER_STATE_BACKGROUND);
1113 event = LAUNCHER_ONSTOP;
1114 }
1115
Hyunyoung Song95786e02020-09-15 00:34:10 -07001116 if (statsLogOrdinal == LAUNCHER_STATE_HOME && mWorkspace != null) {
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001117 logger.withContainerInfo(LauncherAtom.ContainerInfo.newBuilder()
1118 .setWorkspace(
1119 LauncherAtom.WorkspaceContainer.newBuilder()
1120 .setPageIndex(pageIndex)).build());
Becky Qiubfc2da12019-08-01 11:09:38 -07001121 }
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001122 logger.log(event);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001123 }
Becky Qiubfc2da12019-08-01 11:09:38 -07001124
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001125 private void scheduleDeferredCheck() {
1126 mHandler.removeCallbacks(mDeferredOverlayCallbacks);
1127 postAsyncCallback(mHandler, mDeferredOverlayCallbacks);
1128 }
1129
1130 private void checkIfOverlayStillDeferred() {
1131 if (!mDeferOverlayCallbacks) {
1132 return;
1133 }
Sunny Goyal8f965462020-04-23 19:00:36 -07001134 if (isStarted() && (!hasBeenResumed()
1135 || mStateManager.getState().hasFlag(FLAG_NON_INTERACTIVE))) {
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001136 return;
1137 }
1138 mDeferOverlayCallbacks = false;
1139
1140 // Move the client to the correct state. Calling the same method twice is no-op.
1141 if (isStarted()) {
1142 mOverlayManager.onActivityStarted(this);
1143 }
1144 if (hasBeenResumed()) {
1145 mOverlayManager.onActivityResumed(this);
1146 } else {
1147 mOverlayManager.onActivityPaused(this);
1148 }
1149 if (!isStarted()) {
1150 mOverlayManager.onActivityStopped(this);
1151 }
1152 }
1153
1154 public void deferOverlayCallbacksUntilNextResumeOrStop() {
1155 mDeferOverlayCallbacks = true;
1156 }
1157
1158 public LauncherOverlayManager getOverlayManager() {
1159 return mOverlayManager;
Becky Qiubfc2da12019-08-01 11:09:38 -07001160 }
1161
Sunny Goyal35e7d382020-05-08 13:37:58 -07001162 @Override
Winson Chungef528762019-09-06 12:05:52 -07001163 public void onStateSetStart(LauncherState state) {
Sunny Goyal35e7d382020-05-08 13:37:58 -07001164 super.onStateSetStart(state);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001165 if (mDeferOverlayCallbacks) {
1166 scheduleDeferredCheck();
Sunny Goyale9c6f4c2019-05-30 11:35:25 -07001167 }
Sunny Goyal210e1742019-10-17 12:05:38 -07001168 addActivityFlags(ACTIVITY_STATE_TRANSITION_ACTIVE);
Sunny Goyal8f965462020-04-23 19:00:36 -07001169
Sunny Goyal8f965462020-04-23 19:00:36 -07001170 if (state == SPRING_LOADED) {
1171 // Prevent any Un/InstallShortcutReceivers from updating the db while we are
1172 // not on homescreen
Sunny Goyal60e68c92020-08-12 13:59:27 -07001173 ItemInstallQueue.INSTANCE.get(this).pauseModelPush(FLAG_DRAG_AND_DROP);
Sunny Goyal8f965462020-04-23 19:00:36 -07001174 getRotationHelper().setCurrentStateRequest(REQUEST_LOCK);
1175
1176 mWorkspace.showPageIndicatorAtCurrentScroll();
1177 mWorkspace.setClipChildren(false);
1178 }
1179 // When multiple pages are visible, show persistent page indicator
1180 mWorkspace.getPageIndicator().setShouldAutoHide(!state.hasFlag(FLAG_MULTI_PAGE));
thiruram0eabc782021-04-02 14:30:10 -07001181
thiruramc96873c2021-02-11 15:13:47 -08001182 mPrevLauncherState = mStateManager.getCurrentStableState();
thiruram0eabc782021-04-02 14:30:10 -07001183 if (mPrevLauncherState != state && ALL_APPS.equals(state)
1184 // Making sure mAllAppsSessionLogId is null to avoid double logging.
1185 && mAllAppsSessionLogId == null) {
1186 // creates new instance ID since new all apps session is started.
1187 mAllAppsSessionLogId = new InstanceIdSequence().newInstanceId();
Thiru Ramasamy694407c2022-03-08 12:11:24 -08001188 if (getAllAppsEntryEvent().isPresent()) {
1189 getStatsLogManager().logger()
1190 .withContainerInfo(ContainerInfo.newBuilder()
1191 .setWorkspace(WorkspaceContainer.newBuilder()
1192 .setPageIndex(getWorkspace().getCurrentPage())).build())
1193 .log(getAllAppsEntryEvent().get());
1194 }
thiruram0eabc782021-04-02 14:30:10 -07001195 }
Sunny Goyal1eb11242022-09-09 17:14:45 -07001196 updateDisallowBack();
Sunny Goyaldedda052019-05-14 15:23:48 -07001197 }
1198
Thiru Ramasamy5fbac632022-01-28 15:05:36 -08001199 /**
1200 * Returns {@link EventEnum} that should be logged when Launcher enters into AllApps state.
1201 */
Thiru Ramasamy694407c2022-03-08 12:11:24 -08001202 protected Optional<EventEnum> getAllAppsEntryEvent() {
1203 return Optional.of(FeatureFlags.ENABLE_DEVICE_SEARCH.get()
Thiru Ramasamy5fbac632022-01-28 15:05:36 -08001204 ? LAUNCHER_ALLAPPS_ENTRY_WITH_DEVICE_SEARCH
Thiru Ramasamy694407c2022-03-08 12:11:24 -08001205 : LAUNCHER_ALLAPPS_ENTRY);
Thiru Ramasamy5fbac632022-01-28 15:05:36 -08001206 }
1207
Sunny Goyal35e7d382020-05-08 13:37:58 -07001208 @Override
Winson Chungef528762019-09-06 12:05:52 -07001209 public void onStateSetEnd(LauncherState state) {
Sunny Goyalfee1b252020-12-14 12:30:38 -08001210 super.onStateSetEnd(state);
Sihua Ma0593a0d2022-10-03 16:01:48 -07001211 getAppWidgetHolder().setStateIsNormal(state == LauncherState.NORMAL);
Sunny Goyal8f965462020-04-23 19:00:36 -07001212 getWorkspace().setClipChildren(!state.hasFlag(FLAG_MULTI_PAGE));
1213
Winson Chungef528762019-09-06 12:05:52 -07001214 finishAutoCancelActionMode();
Sunny Goyal210e1742019-10-17 12:05:38 -07001215 removeActivityFlags(ACTIVITY_STATE_TRANSITION_ACTIVE);
Sunny Goyal8f965462020-04-23 19:00:36 -07001216
1217 // dispatch window state changed
1218 getWindow().getDecorView().sendAccessibilityEvent(TYPE_WINDOW_STATE_CHANGED);
1219 AccessibilityManagerCompat.sendStateEventToTest(this, state.ordinal);
1220
1221 if (state == NORMAL) {
1222 // Re-enable any Un/InstallShortcutReceiver and now process any queued items
Sunny Goyal60e68c92020-08-12 13:59:27 -07001223 ItemInstallQueue.INSTANCE.get(this)
1224 .resumeModelPush(FLAG_DRAG_AND_DROP);
Sunny Goyal8f965462020-04-23 19:00:36 -07001225
1226 // Clear any rotation locks when going to normal state
1227 getRotationHelper().setCurrentStateRequest(REQUEST_NONE);
1228 }
thiruramc96873c2021-02-11 15:13:47 -08001229
thiruramea56f842021-06-02 16:02:37 -07001230 if (ALL_APPS.equals(mPrevLauncherState) && !ALL_APPS.equals(state)
thiruram0eabc782021-04-02 14:30:10 -07001231 // Making sure mAllAppsSessionLogId is not null to avoid double logging.
thiruramc96873c2021-02-11 15:13:47 -08001232 && mAllAppsSessionLogId != null) {
Samuel Fuface820f52021-06-18 17:23:48 -05001233 getAppsView().reset(false);
Thiru Ramasamy694407c2022-03-08 12:11:24 -08001234 getAllAppsExitEvent().ifPresent(getStatsLogManager().logger()::log);
thiruramc96873c2021-02-11 15:13:47 -08001235 mAllAppsSessionLogId = null;
1236 }
Winson Chungef528762019-09-06 12:05:52 -07001237 }
1238
Thiru Ramasamy694407c2022-03-08 12:11:24 -08001239 /**
1240 * Returns {@link EventEnum} that should be logged when Launcher exists from AllApps state.
1241 */
1242 protected Optional<EventEnum> getAllAppsExitEvent() {
1243 return Optional.of(LAUNCHER_ALLAPPS_EXIT);
1244 }
1245
Michael Jurkacd496d72013-04-11 11:32:45 -07001246 @Override
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001247 protected void onResume() {
Winson Chung5cc62c72019-10-16 11:32:41 -07001248 Object traceToken = TraceHelper.INSTANCE.beginSection(ON_RESUME_EVT,
1249 TraceHelper.FLAG_UI_EVENT);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001250 super.onResume();
Sunny Goyalfca6bc92017-09-28 16:28:34 -07001251
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001252 if (mDeferOverlayCallbacks) {
1253 scheduleDeferredCheck();
1254 } else {
1255 mOverlayManager.onActivityResumed(this);
Adam Cohen9211d422014-10-07 18:14:53 -07001256 }
Mario Bertschler0fc6f682017-02-17 12:16:13 -08001257
Jon Mirandaa82a7dc2022-05-10 11:48:32 -07001258 DragView.removeAllViews(this);
Winson Chung5cc62c72019-10-16 11:32:41 -07001259 TraceHelper.INSTANCE.endSection(traceToken);
Adam Cohen06dff352012-06-01 17:17:08 -07001260 }
1261
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001262 @Override
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001263 protected void onPause() {
Winson Chung997a9232013-07-24 15:33:46 -07001264 // Ensure that items added to Launcher are queued until Launcher returns
Sunny Goyal60e68c92020-08-12 13:59:27 -07001265 ItemInstallQueue.INSTANCE.get(this).pauseModelPush(FLAG_ACTIVITY_PAUSED);
Winson Chung997a9232013-07-24 15:33:46 -07001266
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001267 super.onPause();
Joe Onorato24b6fd82009-11-12 13:47:09 -08001268 mDragController.cancelDrag();
Sunny Goyal9b180102020-03-11 10:02:29 -07001269 mLastTouchUpTime = -1;
Hyunyoung Song497708c2019-05-01 16:16:53 -07001270 mDropTargetBar.animateToVisibility(false);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001271
1272 if (!mDeferOverlayCallbacks) {
1273 mOverlayManager.onActivityPaused(this);
Adam Cohenbffe7452013-07-22 18:21:45 -07001274 }
Sihua Ma0593a0d2022-10-03 16:01:48 -07001275 mAppWidgetHolder.setActivityResumed(false);
Adam Cohenbffe7452013-07-22 18:21:45 -07001276 }
1277
Lucas Dupin87d75202021-07-28 10:24:54 -07001278 /**
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001279 * Restores the previous state, if it exists.
1280 *
1281 * @param savedState The previous state.
1282 */
1283 private void restoreState(Bundle savedState) {
1284 if (savedState == null) {
1285 return;
1286 }
1287
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001288 int stateOrdinal = savedState.getInt(RUNTIME_STATE, NORMAL.ordinal);
Sunny Goyalf9403d92017-10-18 10:55:56 -07001289 LauncherState[] stateValues = LauncherState.values();
1290 LauncherState state = stateValues[stateOrdinal];
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08001291
1292 NonConfigInstance lastInstance = (NonConfigInstance) getLastNonConfigurationInstance();
1293 boolean forceRestore = lastInstance != null
1294 && (lastInstance.config.diff(mOldConfig) & CONFIG_UI_MODE) != 0;
1295 if (forceRestore || !state.shouldDisableRestore()) {
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001296 mStateManager.goToState(state, false /* animated */);
Joe Onorato3a8820b2009-11-10 15:06:42 -08001297 }
1298
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001299 PendingRequestArgs requestArgs = savedState.getParcelable(
1300 RUNTIME_STATE_PENDING_REQUEST_ARGS);
Sunny Goyal2100c782016-08-22 16:00:03 -07001301 if (requestArgs != null) {
1302 setWaitingForResult(requestArgs);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001303 }
Sunny Goyaldedda052019-05-14 15:23:48 -07001304 mPendingActivityRequestCode = savedState.getInt(RUNTIME_STATE_PENDING_REQUEST_CODE);
Sunny Goyal2100c782016-08-22 16:00:03 -07001305
1306 mPendingActivityResult = savedState.getParcelable(RUNTIME_STATE_PENDING_ACTIVITY_RESULT);
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001307
1308 SparseArray<Parcelable> widgetsState =
1309 savedState.getSparseParcelableArray(RUNTIME_STATE_WIDGET_PANEL);
1310 if (widgetsState != null) {
1311 WidgetsFullSheet.show(this, false).restoreHierarchyState(widgetsState);
1312 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001313 }
1314
1315 /**
1316 * Finds all the views we need and configure them properly.
1317 */
Tony Wickham04fca162020-02-05 15:06:52 -08001318 protected void setupViews() {
Becky Qiu3aec5d52022-09-16 11:17:50 -07001319 inflateRootView(R.layout.launcher);
Sunny Goyalcc96aa12018-01-11 09:56:07 -08001320 mDragLayer = findViewById(R.id.drag_layer);
Sunny Goyal3333b0c2016-05-09 20:43:21 -07001321 mFocusHandler = mDragLayer.getFocusIndicatorHelper();
Sunny Goyal966d9012017-06-06 16:43:59 -07001322 mWorkspace = mDragLayer.findViewById(R.id.workspace);
Sunny Goyald0a6ae72016-06-16 12:29:03 -07001323 mWorkspace.initParentViews(mDragLayer);
Sreyas321bfae2020-02-21 17:53:02 -08001324 mOverviewPanel = findViewById(R.id.overview_panel);
Sunny Goyal7c7be8c2018-03-07 19:58:07 -08001325 mHotseat = findViewById(R.id.hotseat);
Adam Cohenb66675a2020-05-15 16:16:17 -07001326 mHotseat.setWorkspace(mWorkspace);
Craig Mautner360310b2012-10-26 15:13:08 -07001327
Winson Chung4c98d922011-05-31 16:50:48 -07001328 // Setup the drag layer
Sunny Goyal5d1873a2018-05-08 11:10:44 -07001329 mDragLayer.setup(mDragController, mWorkspace);
Winson Chung4c98d922011-05-31 16:50:48 -07001330
Hyunyoung Song645764e2016-06-06 14:19:02 -07001331 mWorkspace.setup(mDragController);
Winsonc7d2e832016-07-28 12:24:55 -07001332 // Until the workspace is bound, ensure that we keep the wallpaper offset locked to the
1333 // default state, otherwise we will update to the wrong offsets in RTL
1334 mWorkspace.lockWallpaperToDefaultPage();
Sunny Goyalbb030562021-07-19 16:28:39 -07001335 mWorkspace.bindAndInitFirstWorkspaceScreen();
Hyunyoung Song645764e2016-06-06 14:19:02 -07001336 mDragController.addDragListener(mWorkspace);
Winson Chung4c98d922011-05-31 16:50:48 -07001337
Tony Wickham34d2c912015-09-11 09:27:58 -07001338 // Get the search/delete/uninstall bar
Rajeev Kumar43c0f582017-06-23 15:34:55 -07001339 mDropTargetBar = mDragLayer.findViewById(R.id.drop_target_bar);
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07001340
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001341 // Setup Apps
1342 mAppsView = findViewById(R.id.apps_view);
Fengjiang Lid080b982023-02-01 15:30:30 -08001343 mAppsView.setAllAppsTransitionController(mAllAppsController);
Craig Mautner360310b2012-10-26 15:13:08 -07001344
Govinda Wassermanc06e1512019-04-09 09:56:53 -04001345 // Setup Scrim
1346 mScrimView = findViewById(R.id.scrim_view);
1347
Winson Chung3d503fb2011-07-13 17:25:49 -07001348 // Setup the drag controller (drop targets have to be added in reverse order in priority)
Sunny Goyal47328fd2016-05-25 18:56:41 -07001349 mDropTargetBar.setup(mDragController);
Samuel Fufaacebd1f2021-05-06 10:02:03 -05001350 mAllAppsController.setupViews(mScrimView, mAppsView);
Federico Baron3f255eb2022-12-22 14:40:58 -08001351
1352 if (SHOW_DOT_PAGINATION.get()) {
1353 mWorkspace.getPageIndicator().setShouldAutoHide(true);
Federico Baron3f255eb2022-12-22 14:40:58 -08001354 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001355 }
1356
Federico Baron7539d762022-09-29 09:47:04 -07001357 @Override
1358 public View onCreateView(View parent, String name, Context context, AttributeSet attrs) {
Federico Baron3f255eb2022-12-22 14:40:58 -08001359 if (SHOW_DOT_PAGINATION.get() && WorkspacePageIndicator.class.getName().equals(name)) {
Federico Baron7539d762022-09-29 09:47:04 -07001360 return LayoutInflater.from(context).inflate(R.layout.page_indicator_dots,
1361 (ViewGroup) parent, false);
1362 }
1363 return super.onCreateView(parent, name, context, attrs);
1364 }
1365
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001366 /**
1367 * Creates a view representing a shortcut.
1368 *
1369 * @param info The data structure describing the shortcut.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001370 */
Sunny Goyal95899162019-03-27 16:03:06 -07001371 View createShortcut(WorkspaceItemInfo info) {
Schneider Victor-tulias9f922d32022-04-27 16:39:29 -07001372 // This can be called before PagedView#pageScrollsInitialized returns true, so use the
1373 // first page, which we always assume to be present.
1374 return createShortcut((ViewGroup) mWorkspace.getChildAt(0), info);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001375 }
1376
1377 /**
1378 * Creates a view representing a shortcut inflated from the specified resource.
1379 *
Schneider Victor-tulias9f922d32022-04-27 16:39:29 -07001380 * @param parent The group the shortcut belongs to. This is not necessarily the group where
1381 * the shortcut should be added.
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001382 * @param info The data structure describing the shortcut.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001383 * @return A View inflated from layoutResId.
1384 */
Sunny Goyal95899162019-03-27 16:03:06 -07001385 public View createShortcut(ViewGroup parent, WorkspaceItemInfo info) {
Sunny Goyal9b29ca52017-02-17 10:39:44 -08001386 BubbleTextView favorite = (BubbleTextView) LayoutInflater.from(parent.getContext())
1387 .inflate(R.layout.app_icon, parent, false);
Sunny Goyal95899162019-03-27 16:03:06 -07001388 favorite.applyFromWorkspaceItem(info);
Tracy Zhouba0b5952022-10-14 01:28:07 -07001389 favorite.setOnClickListener(getItemOnClickListener());
Sunny Goyaldcbcc862014-08-12 15:58:36 -07001390 favorite.setOnFocusChangeListener(mFocusHandler);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001391 return favorite;
1392 }
1393
1394 /**
Jon Mirandac476d6e2017-05-04 16:30:01 -07001395 * Add a shortcut to the workspace or to a Folder.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001396 *
1397 * @param data The intent describing the shortcut.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001398 */
sfufa@google.comd0a33232021-09-19 15:59:36 -07001399 protected void completeAddShortcut(Intent data, int container, int screenId, int cellX,
Sunny Goyalfb5096d2016-09-08 14:32:06 -07001400 int cellY, PendingRequestArgs args) {
Pinyao Ting5eee5f42019-10-31 16:47:35 -07001401 if (args.getRequestCode() != REQUEST_CREATE_SHORTCUT
Jon Mirandac476d6e2017-05-04 16:30:01 -07001402 || args.getPendingIntent().getComponent() == null) {
Sunny Goyalfb5096d2016-09-08 14:32:06 -07001403 return;
1404 }
Adam Cohen558baaf2011-08-15 15:22:57 -07001405
Jon Mirandac476d6e2017-05-04 16:30:01 -07001406 int[] cellXY = mTmpAddItemCellCoordinates;
1407 CellLayout layout = getCellLayout(container, screenId);
1408
Sunny Goyaleaf7a952020-07-29 16:54:20 -07001409 WorkspaceItemInfo info = PinRequestHelper.createWorkspaceItemFromPinItemRequest(
Sunny Goyale7b00122019-10-02 16:13:34 -07001410 this, PinRequestHelper.getPinItemRequest(data), 0);
Sunny Goyal782f0c92017-01-19 10:27:54 -08001411
1412 if (info == null) {
Sunny Goyalb57645f2017-03-20 13:57:28 -07001413 // Legacy shortcuts are only supported for primary profile.
1414 info = Process.myUserHandle().equals(args.user)
Sunny Goyal53116c62020-08-07 16:32:18 -07001415 ? ModelUtils.fromLegacyShortcutIntent(this, data) : null;
Sunny Goyal782f0c92017-01-19 10:27:54 -08001416
Sunny Goyalb57645f2017-03-20 13:57:28 -07001417 if (info == null) {
1418 Log.e(TAG, "Unable to parse a valid custom shortcut result");
1419 return;
1420 } else if (!new PackageManagerHelper(this).hasPermissionForActivity(
Sunny Goyal342e4662017-02-02 15:21:08 -08001421 info.intent, args.getPendingIntent().getComponent().getPackageName())) {
Sunny Goyal782f0c92017-01-19 10:27:54 -08001422 // The app is trying to add a shortcut without sufficient permissions
1423 Log.e(TAG, "Ignoring malicious intent " + info.intent.toUri(0));
1424 return;
1425 }
1426 }
1427
Jon Mirandac476d6e2017-05-04 16:30:01 -07001428 if (container < 0) {
1429 // Adding a shortcut to the Workspace.
1430 final View view = createShortcut(info);
1431 boolean foundCellSpan = false;
1432 // First we check if we already know the exact location where we want to add this item.
1433 if (cellX >= 0 && cellY >= 0) {
1434 cellXY[0] = cellX;
1435 cellXY[1] = cellY;
1436 foundCellSpan = true;
Adam Cohen558baaf2011-08-15 15:22:57 -07001437
Hyunyoung Song1ae42422020-01-26 23:25:14 -08001438 DragObject dragObject = new DragObject(getApplicationContext());
1439 dragObject.dragInfo = info;
Jon Mirandac476d6e2017-05-04 16:30:01 -07001440 // If appropriate, either create a folder or add to an existing folder
1441 if (mWorkspace.createUserFolderIfNecessary(view, container, layout, cellXY, 0,
Hyunyoung Song1ae42422020-01-26 23:25:14 -08001442 true, dragObject)) {
Jon Mirandac476d6e2017-05-04 16:30:01 -07001443 return;
1444 }
Jon Mirandac476d6e2017-05-04 16:30:01 -07001445 if (mWorkspace.addToExistingFolderIfNecessary(view, layout, cellXY, 0, dragObject,
1446 true)) {
1447 return;
1448 }
1449 } else {
1450 foundCellSpan = layout.findCellForSpan(cellXY, 1, 1);
1451 }
1452
1453 if (!foundCellSpan) {
Yogisha Dixit104d09f2021-07-19 14:05:17 +01001454 mWorkspace.onNoCellFound(layout, info, /* logInstanceId= */ null);
Adam Cohen558baaf2011-08-15 15:22:57 -07001455 return;
1456 }
Jon Mirandac476d6e2017-05-04 16:30:01 -07001457
1458 getModelWriter().addItemToDatabase(info, container, screenId, cellXY[0], cellXY[1]);
1459 mWorkspace.addInScreen(view, info);
Michael Jurkad3ef3062010-11-23 16:23:58 -08001460 } else {
Jon Mirandac476d6e2017-05-04 16:30:01 -07001461 // Adding a shortcut to a Folder.
Sunny Goyale29897f52017-07-20 10:09:42 -07001462 FolderIcon folderIcon = findFolderIcon(container);
Jon Mirandac476d6e2017-05-04 16:30:01 -07001463 if (folderIcon != null) {
1464 FolderInfo folderInfo = (FolderInfo) folderIcon.getTag();
1465 folderInfo.add(info, args.rank, false);
1466 } else {
Sunny Goyale29897f52017-07-20 10:09:42 -07001467 Log.e(TAG, "Could not find folder with id " + container + " to add shortcut.");
Jon Mirandac476d6e2017-05-04 16:30:01 -07001468 }
Michael Jurka0280c3b2010-09-17 15:00:07 -07001469 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001470 }
1471
Tony Wickhamc7cbf252021-05-24 15:46:48 -07001472 @Override
1473 public @Nullable FolderIcon findFolderIcon(final int folderIconId) {
Sunny Goyal83fd25e2018-07-09 16:47:01 -07001474 return (FolderIcon) mWorkspace.getHomescreenIconByItemId(folderIconId);
Sunny Goyale29897f52017-07-20 10:09:42 -07001475 }
1476
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001477 /**
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001478 * Add a widget to the workspace.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001479 *
Romain Guy5bbc91b2010-08-18 11:38:46 -07001480 * @param appWidgetId The app widget id
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001481 */
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001482 @Thunk
1483 void completeAddAppWidget(int appWidgetId, ItemInfo itemInfo,
Adam Cohen59400422014-03-05 18:07:04 -08001484 AppWidgetHostView hostView, LauncherAppWidgetProviderInfo appWidgetInfo) {
1485
Adam Cohened66b2b2012-01-23 17:28:51 -08001486 if (appWidgetInfo == null) {
Sunny Goyal2e1efb42016-03-03 16:58:55 -08001487 appWidgetInfo = mAppWidgetManager.getLauncherAppWidgetInfo(appWidgetId);
Adam Cohened66b2b2012-01-23 17:28:51 -08001488 }
Romain Guycbb89e42009-06-08 15:52:54 -07001489
Yogisha Dixit0b15c7e2021-05-10 12:01:58 +01001490 if (hostView == null) {
1491 // Perform actual inflation because we're live
Sihua Ma0593a0d2022-10-03 16:01:48 -07001492 hostView = mAppWidgetHolder.createView(this, appWidgetId, appWidgetInfo);
Yogisha Dixit0b15c7e2021-05-10 12:01:58 +01001493 }
1494
Adam Cohen59400422014-03-05 18:07:04 -08001495 LauncherAppWidgetInfo launcherInfo;
Yogisha Dixit0b15c7e2021-05-10 12:01:58 +01001496 launcherInfo =
1497 new LauncherAppWidgetInfo(
1498 appWidgetId, appWidgetInfo.provider, appWidgetInfo, hostView);
Sunny Goyal2100c782016-08-22 16:00:03 -07001499 launcherInfo.spanX = itemInfo.spanX;
1500 launcherInfo.spanY = itemInfo.spanY;
1501 launcherInfo.minSpanX = itemInfo.minSpanX;
1502 launcherInfo.minSpanY = itemInfo.minSpanY;
Sunny Goyal952e63d2017-08-16 04:59:08 -07001503 launcherInfo.user = appWidgetInfo.getProfile();
Yogisha Dixit658c5da2021-05-24 23:23:15 +01001504 if (itemInfo instanceof PendingAddWidgetInfo) {
1505 launcherInfo.sourceContainer = ((PendingAddWidgetInfo) itemInfo).sourceContainer;
1506 } else if (itemInfo instanceof PendingRequestArgs) {
1507 launcherInfo.sourceContainer =
1508 ((PendingRequestArgs) itemInfo).getWidgetSourceContainer();
1509 }
Sunny Goyal669b71f2023-01-27 14:37:07 -08001510 CellPos presenterPos = getCellPosMapper().mapModelToPresenter(itemInfo);
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001511 getModelWriter().addItemToDatabase(launcherInfo,
Sunny Goyal669b71f2023-01-27 14:37:07 -08001512 itemInfo.container, presenterPos.screenId, presenterPos.cellX, presenterPos.cellY);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001513
Sunny Goyal2100c782016-08-22 16:00:03 -07001514 hostView.setVisibility(View.VISIBLE);
Sunny Goyald5462aa2016-11-22 16:52:39 +05301515 prepareAppWidget(hostView, launcherInfo);
1516 mWorkspace.addInScreen(hostView, launcherInfo);
Pinyao Tingc9074272019-11-11 11:51:44 -08001517 announceForAccessibility(R.string.item_added_to_workspace);
Yogisha Dixit037a5362021-03-22 14:13:03 +00001518
1519 // Show the widget resize frame.
1520 if (hostView instanceof LauncherAppWidgetHostView) {
1521 final LauncherAppWidgetHostView launcherHostView = (LauncherAppWidgetHostView) hostView;
Sunny Goyal669b71f2023-01-27 14:37:07 -08001522 CellLayout cellLayout = getCellLayout(launcherInfo.container, presenterPos.screenId);
Yogisha Dixit037a5362021-03-22 14:13:03 +00001523 if (mStateManager.getState() == NORMAL) {
Yogisha Dixit7b1d25b2021-10-14 13:06:40 +01001524 AppWidgetResizeFrame.showForWidget(launcherHostView, cellLayout);
Yogisha Dixit037a5362021-03-22 14:13:03 +00001525 } else {
1526 mStateManager.addStateListener(new StateManager.StateListener<LauncherState>() {
1527 @Override
1528 public void onStateTransitionComplete(LauncherState finalState) {
1529 if (mPrevLauncherState == SPRING_LOADED && finalState == NORMAL) {
1530 AppWidgetResizeFrame.showForWidget(launcherHostView, cellLayout);
1531 mStateManager.removeStateListener(this);
1532 }
1533 }
1534 });
1535 }
1536 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001537 }
Romain Guycbb89e42009-06-08 15:52:54 -07001538
Sunny Goyald5462aa2016-11-22 16:52:39 +05301539 private void prepareAppWidget(AppWidgetHostView hostView, LauncherAppWidgetInfo item) {
Sunny Goyal87af0fd2016-05-16 14:56:02 -07001540 hostView.setTag(item);
1541 item.onBindAppWidget(this, hostView);
Sunny Goyal87af0fd2016-05-16 14:56:02 -07001542 hostView.setFocusable(true);
1543 hostView.setOnFocusChangeListener(mFocusHandler);
Sunny Goyal25c2e3e2015-10-28 23:28:21 -07001544 }
1545
Sunny Goyala992ac92023-01-10 17:50:32 -08001546 private final ScreenOnListener mScreenOnListener = this::onScreenOnChanged;
Adam Cohended9f8d2010-11-03 13:25:16 -07001547
Sunny Goyal9c2b9602020-01-07 13:07:55 -08001548 private void updateNotificationDots(Predicate<PackageUserKey> updatedDots) {
Tony Wickhamf34bee82018-12-03 18:11:39 -08001549 mWorkspace.updateNotificationDots(updatedDots);
1550 mAppsView.getAppsStore().updateNotificationDots(updatedDots);
Tony Wickham010d2552017-01-20 08:15:28 -08001551 }
1552
Adam Cohended9f8d2010-11-03 13:25:16 -07001553 @Override
1554 public void onAttachedToWindow() {
1555 super.onAttachedToWindow();
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001556 mOverlayManager.onAttachedToWindow();
Adam Cohended9f8d2010-11-03 13:25:16 -07001557 }
1558
1559 @Override
1560 public void onDetachedFromWindow() {
1561 super.onDetachedFromWindow();
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001562 mOverlayManager.onDetachedFromWindow();
1563 closeContextMenu();
Adam Cohended9f8d2010-11-03 13:25:16 -07001564 }
1565
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -07001566 @Override
1567 public Object onRetainNonConfigurationInstance() {
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08001568 NonConfigInstance instance = new NonConfigInstance();
1569 instance.config = new Configuration(mOldConfig);
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08001570 return instance;
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -07001571 }
1572
Sunny Goyalc4fa8c32017-11-07 12:23:58 -08001573 public AllAppsTransitionController getAllAppsController() {
1574 return mAllAppsController;
1575 }
1576
Sunny Goyal9d69c8d2018-03-19 13:41:31 -07001577 @Override
Winson Chunga6945242014-01-08 14:04:34 -08001578 public DragLayer getDragLayer() {
1579 return mDragLayer;
1580 }
1581
Brian Isganitis1664c9f2022-01-14 23:15:47 -05001582 @Override
1583 public ActivityAllAppsContainerView<Launcher> getAppsView() {
Winson Chungb745afb2015-03-02 11:51:23 -08001584 return mAppsView;
1585 }
1586
Shikha Malhotra0f2e1b62022-03-27 21:02:21 +00001587 public Workspace<?> getWorkspace() {
Winson Chunga6945242014-01-08 14:04:34 -08001588 return mWorkspace;
1589 }
1590
1591 public Hotseat getHotseat() {
1592 return mHotseat;
1593 }
1594
Sunny Goyal7c7be8c2018-03-07 19:58:07 -08001595 public <T extends View> T getOverviewPanel() {
Winson Chung8ae41982017-11-10 11:42:13 -08001596 return (T) mOverviewPanel;
Winson Chunga6945242014-01-08 14:04:34 -08001597 }
1598
Sunny Goyal47328fd2016-05-25 18:56:41 -07001599 public DropTargetBar getDropTargetBar() {
1600 return mDropTargetBar;
Tony Wickham34d2c912015-09-11 09:27:58 -07001601 }
1602
Tony Wickhamb4821882021-04-23 14:26:45 -07001603 @Override
Tony Wickham490a8ab2020-04-01 17:03:58 -07001604 public ScrimView getScrimView() {
1605 return mScrimView;
1606 }
1607
Sihua Ma0593a0d2022-10-03 16:01:48 -07001608 public LauncherWidgetHolder getAppWidgetHolder() {
1609 return mAppWidgetHolder;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001610 }
Romain Guycbb89e42009-06-08 15:52:54 -07001611
Sihua Ma0593a0d2022-10-03 16:01:48 -07001612 protected LauncherWidgetHolder createAppWidgetHolder() {
Sihua Ma1db8bc22022-11-08 17:13:13 -08001613 return LauncherWidgetHolder.HolderFactory.newFactory(this).newInstance(
1614 this, appWidgetId -> getWorkspace().removeWidget(appWidgetId));
Cyrus Boadway0d309db2021-04-14 12:29:14 +00001615 }
1616
Winson Chunga9abd0e2010-10-27 17:18:37 -07001617 public LauncherModel getModel() {
1618 return mModel;
1619 }
1620
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001621 public ModelWriter getModelWriter() {
1622 return mModelWriter;
1623 }
1624
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001625 @Override
Adam Cohen79d90c52016-04-22 13:29:20 -07001626 public SharedPreferences getSharedPrefs() {
Winson Chunga6945242014-01-08 14:04:34 -08001627 return mSharedPrefs;
1628 }
1629
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001630 @Override
1631 public SharedPreferences getDevicePrefs() {
Stefan Andonian146701c2022-11-10 23:07:40 +00001632 return LauncherPrefs.getDevicePrefs(this);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001633 }
1634
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001635 public int getOrientation() {
1636 return mOldConfig.orientation;
1637 }
Jon Miranda6bed3502017-09-19 14:43:17 -07001638
Becky Qiu4ed3dfc2022-10-19 16:58:22 -07001639 public BaseSearchConfig getSearchConfig() {
1640 return mBaseSearchConfig;
Luca Zuccarinibda972b2022-10-03 11:48:27 +00001641 }
1642
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001643 @Override
1644 protected void onNewIntent(Intent intent) {
Brian Isganitisfdd044e2023-03-02 19:45:23 +00001645 if (Utilities.isRunningInTestHarness()) {
vadimtbaf5fbb2019-12-16 18:56:09 -08001646 Log.d(TestProtocol.PERMANENT_DIAG_TAG, "Launcher.onNewIntent: " + intent);
1647 }
Winson Chung5cc62c72019-10-16 11:32:41 -07001648 Object traceToken = TraceHelper.INSTANCE.beginSection(ON_NEW_INTENT_EVT);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001649 super.onNewIntent(intent);
1650
Sunny Goyalf4aceab2017-12-06 16:16:31 -08001651 boolean alreadyOnHome = hasWindowFocus() && ((intent.getFlags() &
Winson15f8b172015-08-19 11:02:39 -07001652 Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT)
1653 != Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT);
Sunny Goyal85313732016-09-28 12:00:07 -07001654
1655 // Check this condition before handling isActionMain, as this will get reset.
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001656 boolean shouldMoveToDefaultScreen = alreadyOnHome && isInState(NORMAL)
Sunny Goyalf9403d92017-10-18 10:55:56 -07001657 && AbstractFloatingView.getTopOpenView(this) == null;
Winson15f8b172015-08-19 11:02:39 -07001658 boolean isActionMain = Intent.ACTION_MAIN.equals(intent.getAction());
Winson Chung1c2d5222021-06-08 11:50:13 -07001659 boolean internalStateHandled = ACTIVITY_TRACKER.handleNewIntent(this);
kholoud mohamedceec31b2022-02-03 15:44:25 +00001660
Winson15f8b172015-08-19 11:02:39 -07001661 if (isActionMain) {
Sunny Goyald3864fa2017-11-14 15:06:36 -08001662 if (!internalStateHandled) {
Sunny Goyald3864fa2017-11-14 15:06:36 -08001663 // In all these cases, only animate if we're already on home
Andy Wickham65ced1b2020-03-07 02:14:19 +00001664 closeOpenViews(isStarted());
Jon Mirandafeba90f2016-10-06 10:53:29 -07001665
Sunny Goyala2467272018-03-16 14:53:05 -07001666 if (!isInState(NORMAL)) {
1667 // Only change state, if not already the same. This prevents cancelling any
1668 // animations running as part of resume
Sunny Goyalfee1b252020-12-14 12:30:38 -08001669 mStateManager.goToState(NORMAL, mStateManager.shouldAnimateStateChange());
Sunny Goyala2467272018-03-16 14:53:05 -07001670 }
Sunny Goyald3864fa2017-11-14 15:06:36 -08001671
1672 // Reset the apps view
Sunny Goyal5d1873a2018-05-08 11:10:44 -07001673 if (!alreadyOnHome) {
Sunny Goyal7185dd62018-03-14 17:51:49 -07001674 mAppsView.reset(isStarted() /* animate */);
Sunny Goyald3864fa2017-11-14 15:06:36 -08001675 }
1676
Sunny Goyalaad33592018-08-07 17:20:35 -07001677 if (shouldMoveToDefaultScreen && !mWorkspace.isHandlingTouch()) {
Sunny Goyald3864fa2017-11-14 15:06:36 -08001678 mWorkspace.post(mWorkspace::moveToDefaultScreen);
1679 }
1680 }
Adam Cohen6fecd412013-10-02 17:41:50 -07001681
Adam Cohen9211d422014-10-07 18:14:53 -07001682 if (mLauncherCallbacks != null) {
Sunny Goyal85462132018-04-24 11:39:37 -07001683 mLauncherCallbacks.onHomeIntent(internalStateHandled);
Adam Cohen9211d422014-10-07 18:14:53 -07001684 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001685 mOverlayManager.hideOverlay(isStarted() && !isForceInvisible());
Sunny Goyal30ac97d2020-06-24 23:47:46 -07001686 handleGestureContract(intent);
Sunny Goyal512a2c12020-04-08 12:52:45 -07001687 } else if (Intent.ACTION_ALL_APPS.equals(intent.getAction())) {
Winson Chungdd15ace2020-08-04 15:52:01 -07001688 showAllAppsFromIntent(alreadyOnHome);
kholoud mohamedceec31b2022-02-03 15:44:25 +00001689 } else if (Intent.ACTION_SHOW_WORK_APPS.equals(intent.getAction())) {
1690 showAllAppsWorkTabFromIntent(alreadyOnHome);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001691 }
Winson15f8b172015-08-19 11:02:39 -07001692
Winson Chung5cc62c72019-10-16 11:32:41 -07001693 TraceHelper.INSTANCE.endSection(traceToken);
Adam Coppa120b8e2013-11-12 16:26:04 +00001694 }
1695
Winson Chungdd15ace2020-08-04 15:52:01 -07001696 protected void showAllAppsFromIntent(boolean alreadyOnHome) {
1697 AbstractFloatingView.closeAllOpenViews(this);
1698 getStateManager().goToState(ALL_APPS, alreadyOnHome);
1699 }
1700
kholoud mohamedceec31b2022-02-03 15:44:25 +00001701 private void showAllAppsWorkTabFromIntent(boolean alreadyOnHome) {
1702 showAllAppsFromIntent(alreadyOnHome);
Sunny Goyal34c499d2023-01-24 12:43:18 -08001703 mAppsView.switchToTab(ActivityAllAppsContainerView.AdapterHolder.WORK);
kholoud mohamedceec31b2022-02-03 15:44:25 +00001704 }
1705
Sunny Goyaldeb91c42020-03-24 02:17:59 -07001706 /**
Sunny Goyal30ac97d2020-06-24 23:47:46 -07001707 * Handles gesture nav contract
1708 */
1709 protected void handleGestureContract(Intent intent) {
1710 GestureNavContract gnc = GestureNavContract.fromIntent(intent);
1711 if (gnc != null) {
1712 AbstractFloatingView.closeOpenViews(this, false, TYPE_ICON_SURFACE);
1713 FloatingSurfaceView.show(this, gnc);
1714 }
1715 }
1716
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001717 @Override
Adam Cohen1462de32012-07-24 22:34:36 -07001718 public void onRestoreInstanceState(Bundle state) {
1719 super.onRestoreInstanceState(state);
Andras Kloczl55edfe52021-05-14 12:21:30 +02001720 if (mSynchronouslyBoundPages != null) {
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07001721 mSynchronouslyBoundPages.forEach(screenId -> {
1722 int pageIndex = mWorkspace.getPageIndexForScreenId(screenId);
1723 if (pageIndex != PagedView.INVALID_PAGE) {
1724 mWorkspace.restoreInstanceStateForChild(pageIndex);
1725 }
1726 });
Andras Kloczl55edfe52021-05-14 12:21:30 +02001727 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001728 }
1729
1730 @Override
1731 protected void onSaveInstanceState(Bundle outState) {
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07001732 outState.putIntArray(RUNTIME_STATE_CURRENT_SCREEN_IDS,
1733 mWorkspace.getCurrentPageScreenIds().getArray().toArray());
Sunny Goyalea609262017-10-25 15:47:38 -07001734 outState.putInt(RUNTIME_STATE, mStateManager.getState().ordinal);
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001735
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001736 AbstractFloatingView widgets = AbstractFloatingView
1737 .getOpenView(this, AbstractFloatingView.TYPE_WIDGETS_FULL_SHEET);
1738 if (widgets != null) {
1739 SparseArray<Parcelable> widgetsState = new SparseArray<>();
1740 widgets.saveHierarchyState(widgetsState);
1741 outState.putSparseParcelableArray(RUNTIME_STATE_WIDGET_PANEL, widgetsState);
1742 } else {
1743 outState.remove(RUNTIME_STATE_WIDGET_PANEL);
1744 }
1745
Federico Baron8bf1bca2022-09-27 16:19:11 -07001746 // We close any open folders and shortcut containers that are not safe for rebind,
1747 // and we need to make sure this state is reflected.
1748 AbstractFloatingView.closeAllOpenViewsExcept(
1749 this, isStarted() && !isForceInvisible(), TYPE_REBIND_SAFE);
Pinyao Tinga74b63a2019-07-17 23:26:06 -07001750 finishAutoCancelActionMode();
Tony Wickham49c8d292016-07-01 11:44:34 -07001751
Sunny Goyal2100c782016-08-22 16:00:03 -07001752 if (mPendingRequestArgs != null) {
1753 outState.putParcelable(RUNTIME_STATE_PENDING_REQUEST_ARGS, mPendingRequestArgs);
1754 }
Sunny Goyaldedda052019-05-14 15:23:48 -07001755 outState.putInt(RUNTIME_STATE_PENDING_REQUEST_CODE, mPendingActivityRequestCode);
1756
Sunny Goyal2100c782016-08-22 16:00:03 -07001757 if (mPendingActivityResult != null) {
1758 outState.putParcelable(RUNTIME_STATE_PENDING_ACTIVITY_RESULT, mPendingActivityResult);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001759 }
1760
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001761 super.onSaveInstanceState(outState);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001762 mOverlayManager.onActivitySaveInstanceState(this, outState);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001763 }
1764
1765 @Override
1766 public void onDestroy() {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001767 super.onDestroy();
Sunny Goyale84c5b82019-09-26 17:05:31 -07001768 ACTIVITY_TRACKER.onActivityDestroyed(this);
Romain Guycbb89e42009-06-08 15:52:54 -07001769
Sunny Goyala992ac92023-01-10 17:50:32 -08001770 ScreenOnTracker.INSTANCE.get(this).removeListener(mScreenOnListener);
Sunny Goyalaaf7d1d2016-05-17 13:38:54 -07001771 mWorkspace.removeFolderListeners();
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001772 PluginManagerWrapper.INSTANCE.get(this).removePluginListener(this);
Winson Chunge7a03942011-08-05 15:05:12 -07001773
Sunny Goyala7a5bf32020-01-05 15:35:29 +05301774 mModel.removeCallbacks(this);
Sunny Goyal623eddd2018-03-02 12:24:41 -08001775 mRotationHelper.destroy();
Sunny Goyal745bad92016-05-02 10:54:12 -07001776
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001777 try {
Sihua Ma0593a0d2022-10-03 16:01:48 -07001778 mAppWidgetHolder.stopListening();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001779 } catch (NullPointerException ex) {
Joe Onoratoa30ce8e2009-11-11 08:16:49 -08001780 Log.w(TAG, "problem while stopping AppWidgetHost during Launcher destruction", ex);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001781 }
Sihua Maaa2b8722022-10-25 15:17:58 -07001782 mAppWidgetHolder.destroy();
Patrick Dubroy2313eff2011-01-11 20:01:31 -08001783
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001784 TextKeyListener.getInstance().release();
Tony2917a8b2017-07-31 23:29:42 -07001785 clearPendingBinds();
Hyunyoung Song31971a32019-01-27 12:31:12 -08001786 LauncherAppState.getIDP(this).removeOnChangeListener(this);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001787
1788 mOverlayManager.onActivityDestroyed(this);
Samuel Fufa41d909f2020-03-20 16:27:09 -07001789 mUserChangedCallbackCloseable.close();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001790 }
1791
Sunny Goyalae502842016-06-17 08:43:56 -07001792 public LauncherAccessibilityDelegate getAccessibilityDelegate() {
1793 return mAccessibilityDelegate;
1794 }
1795
Adam Cohena9cf38f2011-05-02 15:36:58 -07001796 public DragController getDragController() {
1797 return mDragController;
1798 }
1799
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001800 @Override
Sunny Goyal0eca4e22016-07-20 11:43:06 -07001801 public void startActivityForResult(Intent intent, int requestCode, Bundle options) {
Sunny Goyaldedda052019-05-14 15:23:48 -07001802 if (requestCode != -1) {
1803 mPendingActivityRequestCode = requestCode;
1804 }
Sunny Goyal210e1742019-10-17 12:05:38 -07001805 super.startActivityForResult(intent, requestCode, options);
Adam Cohen173f7112015-03-27 15:14:00 -07001806 }
1807
1808 @Override
Sunny Goyaldedda052019-05-14 15:23:48 -07001809 public void startIntentSenderForResult(IntentSender intent, int requestCode,
Adam Cohen173f7112015-03-27 15:14:00 -07001810 Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags, Bundle options) {
Sunny Goyaldedda052019-05-14 15:23:48 -07001811 if (requestCode != -1) {
1812 mPendingActivityRequestCode = requestCode;
1813 }
Sunny Goyal210e1742019-10-17 12:05:38 -07001814 try {
1815 super.startIntentSenderForResult(intent, requestCode,
1816 fillInIntent, flagsMask, flagsValues, extraFlags, options);
1817 } catch (IntentSender.SendIntentException e) {
1818 throw new ActivityNotFoundException();
Adam Cohen173f7112015-03-27 15:14:00 -07001819 }
1820 }
1821
Winson Chung70d72102011-08-12 11:24:35 -07001822 /**
1823 * Indicates that we want global search for this activity by setting the globalSearch
1824 * argument for {@link #startSearch} to true.
1825 */
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001826 @Override
Romain Guycbb89e42009-06-08 15:52:54 -07001827 public void startSearch(String initialQuery, boolean selectInitialQuery,
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001828 Bundle appSearchData, boolean globalSearch) {
1829 if (appSearchData == null) {
1830 appSearchData = new Bundle();
Bjorn Bringert32b12d22013-06-06 13:00:41 +01001831 appSearchData.putString("source", "launcher-search");
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001832 }
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07001833
Sunny Goyal6f28e712016-09-13 14:19:29 -07001834 if (mLauncherCallbacks == null ||
1835 !mLauncherCallbacks.startSearch(initialQuery, selectInitialQuery, appSearchData)) {
1836 // Starting search from the callbacks failed. Start the default global search.
Sunny Goyalf4aceab2017-12-06 16:16:31 -08001837 super.startSearch(initialQuery, selectInitialQuery, appSearchData, true);
Ian Parkinson047036e2014-09-01 15:40:53 +01001838 }
Winson Chungcd99cd32015-04-29 11:03:24 -07001839
1840 // We need to show the workspace after starting the search
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001841 mStateManager.goToState(NORMAL);
Bjorn Bringertc459e522013-06-07 19:36:01 +01001842 }
1843
Joe Onorato9c1289c2009-08-17 11:03:03 -04001844 public boolean isWorkspaceLocked() {
Sunny Goyal2100c782016-08-22 16:00:03 -07001845 return mWorkspaceLoading || mPendingRequestArgs != null;
Joe Onorato9c1289c2009-08-17 11:03:03 -04001846 }
1847
Adam Cohen517a7f52014-03-01 12:12:59 -08001848 public boolean isWorkspaceLoading() {
1849 return mWorkspaceLoading;
1850 }
1851
Brian Isganitis099945b2022-01-31 18:15:00 -05001852 @Override
1853 public boolean isBindingItems() {
1854 return mWorkspaceLoading;
1855 }
1856
Anjali Koppalff7ceff2014-05-01 18:26:37 -07001857 private void setWorkspaceLoading(boolean value) {
Schneider Victor-tulias6b94a962023-02-22 12:08:21 -08001858 if (TestProtocol.sDebugTracing) {
1859 Log.d(TestProtocol.FLAKY_BINDING, "running: setWorkspaceLoading=" + value);
1860 }
Anjali Koppalff7ceff2014-05-01 18:26:37 -07001861 mWorkspaceLoading = value;
Anjali Koppalff7ceff2014-05-01 18:26:37 -07001862 }
1863
Sunny Goyal04a324a2017-01-20 21:08:59 -08001864 public void setWaitingForResult(PendingRequestArgs args) {
Sunny Goyal2100c782016-08-22 16:00:03 -07001865 mPendingRequestArgs = args;
Adam Cohen9211d422014-10-07 18:14:53 -07001866 }
Anjali Koppalff7ceff2014-05-01 18:26:37 -07001867
Sunny Goyal2100c782016-08-22 16:00:03 -07001868 void addAppWidgetFromDropImpl(int appWidgetId, ItemInfo info, AppWidgetHostView boundWidget,
Sunny Goyal04a324a2017-01-20 21:08:59 -08001869 WidgetAddFlowHandler addFlowHandler) {
Tony Wickhama0628cc2015-10-14 15:23:04 -07001870 if (LOGD) {
1871 Log.d(TAG, "Adding widget from drop");
1872 }
Sunny Goyal04a324a2017-01-20 21:08:59 -08001873 addAppWidgetImpl(appWidgetId, info, boundWidget, addFlowHandler, 0);
Adam Cohenad4e15c2013-10-17 16:21:35 -07001874 }
1875
Sunny Goyal2100c782016-08-22 16:00:03 -07001876 void addAppWidgetImpl(int appWidgetId, ItemInfo info,
Sunny Goyal04a324a2017-01-20 21:08:59 -08001877 AppWidgetHostView boundWidget, WidgetAddFlowHandler addFlowHandler, int delay) {
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001878 if (!addFlowHandler.startConfigActivity(this, appWidgetId, info,
1879 REQUEST_CREATE_APPWIDGET)) {
Sunny Goyal04a324a2017-01-20 21:08:59 -08001880 // If the configuration flow was not started, add the widget
Michael Jurkaaf442092010-06-10 17:01:57 -07001881
Adam Cohenad4e15c2013-10-17 16:21:35 -07001882 Runnable onComplete = new Runnable() {
1883 @Override
1884 public void run() {
1885 // Exit spring loaded mode if necessary after adding the widget
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001886 mStateManager.goToState(NORMAL, SPRING_LOADED_EXIT_DELAY);
Adam Cohenad4e15c2013-10-17 16:21:35 -07001887 }
1888 };
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001889 completeAddAppWidget(appWidgetId, info, boundWidget,
1890 addFlowHandler.getProviderInfo(this));
Sunny Goyal6e379fc2020-03-19 16:08:14 -07001891 mWorkspace.removeExtraEmptyScreenDelayed(delay, false, onComplete);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001892 }
1893 }
Romain Guycbb89e42009-06-08 15:52:54 -07001894
Sunny Goyalefb7e842018-10-04 15:11:00 -07001895 public void addPendingItem(PendingAddItemInfo info, int container, int screenId,
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08001896 int[] cell, int spanX, int spanY) {
Sunny Goyal669b71f2023-01-27 14:37:07 -08001897 if (cell == null) {
1898 CellPos modelPos = getCellPosMapper().mapPresenterToModel(0, 0, screenId, container);
1899 info.screenId = modelPos.screenId;
1900 } else {
1901 CellPos modelPos = getCellPosMapper().mapPresenterToModel(
1902 cell[0], cell[1], screenId, container);
1903 info.screenId = modelPos.screenId;
1904 info.cellX = modelPos.cellX;
1905 info.cellY = modelPos.cellY;
Sunny Goyal2100c782016-08-22 16:00:03 -07001906 }
Sunny Goyal669b71f2023-01-27 14:37:07 -08001907 info.container = container;
Sunny Goyal2100c782016-08-22 16:00:03 -07001908 info.spanX = spanX;
1909 info.spanY = spanY;
1910
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08001911 switch (info.itemType) {
1912 case LauncherSettings.Favorites.ITEM_TYPE_CUSTOM_APPWIDGET:
1913 case LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET:
Sunny Goyal2100c782016-08-22 16:00:03 -07001914 addAppWidgetFromDrop((PendingAddWidgetInfo) info);
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08001915 break;
1916 case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT:
Sunny Goyal782f0c92017-01-19 10:27:54 -08001917 processShortcutFromDrop((PendingAddShortcutInfo) info);
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08001918 break;
1919 default:
1920 throw new IllegalStateException("Unknown item type: " + info.itemType);
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001921 }
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08001922 }
1923
Adam Cohenfbba09b2011-07-18 21:43:05 -07001924 /**
1925 * Process a shortcut drop.
Adam Cohenfbba09b2011-07-18 21:43:05 -07001926 */
Sunny Goyal782f0c92017-01-19 10:27:54 -08001927 private void processShortcutFromDrop(PendingAddShortcutInfo info) {
Sunny Goyalfb5096d2016-09-08 14:32:06 -07001928 Intent intent = new Intent(Intent.ACTION_CREATE_SHORTCUT).setComponent(info.componentName);
1929 setWaitingForResult(PendingRequestArgs.forIntent(REQUEST_CREATE_SHORTCUT, intent, info));
vadimtcf275c12020-04-15 12:43:01 -07001930 TestLogging.recordEvent(TestProtocol.SEQUENCE_MAIN, "start: processShortcutFromDrop");
Sunny Goyal239d6e92023-02-07 13:40:11 -08001931 if (!info.getActivityInfo(this).startConfigActivity(this, REQUEST_CREATE_SHORTCUT)) {
Sunny Goyal782f0c92017-01-19 10:27:54 -08001932 handleActivityResult(REQUEST_CREATE_SHORTCUT, RESULT_CANCELED, null);
1933 }
Michael Jurka0280c3b2010-09-17 15:00:07 -07001934 }
1935
Adam Cohenfbba09b2011-07-18 21:43:05 -07001936 /**
1937 * Process a widget drop.
Adam Cohenfbba09b2011-07-18 21:43:05 -07001938 */
Sunny Goyal2100c782016-08-22 16:00:03 -07001939 private void addAppWidgetFromDrop(PendingAddWidgetInfo info) {
Adam Cohened66b2b2012-01-23 17:28:51 -08001940 AppWidgetHostView hostView = info.boundWidget;
Sunny Goyal952e63d2017-08-16 04:59:08 -07001941 final int appWidgetId;
Sunny Goyal8a0dc382017-01-25 11:30:06 -08001942 WidgetAddFlowHandler addFlowHandler = info.getHandler();
Adam Cohened66b2b2012-01-23 17:28:51 -08001943 if (hostView != null) {
Tony Wickhama0628cc2015-10-14 15:23:04 -07001944 // In the case where we've prebound the widget, we remove it from the DragLayer
1945 if (LOGD) {
1946 Log.d(TAG, "Removing widget view from drag layer and setting boundWidget to null");
1947 }
1948 getDragLayer().removeView(hostView);
1949
Adam Cohened66b2b2012-01-23 17:28:51 -08001950 appWidgetId = hostView.getAppWidgetId();
Sunny Goyal04a324a2017-01-20 21:08:59 -08001951 addAppWidgetFromDropImpl(appWidgetId, info, hostView, addFlowHandler);
Sunny Goyal5b9ebca2015-06-01 18:37:32 -07001952
1953 // Clear the boundWidget so that it doesn't get destroyed.
1954 info.boundWidget = null;
Adam Cohened66b2b2012-01-23 17:28:51 -08001955 } else {
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001956 // In this case, we either need to start an activity to get permission to bind
1957 // the widget, or we need to start an activity to configure the widget, or both.
Pinyao Tingc7a6c292019-08-26 14:36:02 -07001958 if (info.itemType == LauncherSettings.Favorites.ITEM_TYPE_CUSTOM_APPWIDGET) {
1959 appWidgetId = CustomWidgetManager.INSTANCE.get(this).getWidgetIdForCustomProvider(
1960 info.componentName);
Sunny Goyal952e63d2017-08-16 04:59:08 -07001961 } else {
Sihua Ma0593a0d2022-10-03 16:01:48 -07001962 appWidgetId = getAppWidgetHolder().allocateAppWidgetId();
Sunny Goyal952e63d2017-08-16 04:59:08 -07001963 }
Adam Cohendd70d662012-10-04 16:53:44 -07001964 Bundle options = info.bindOptions;
1965
Sunny Goyalffe83f12014-08-14 17:39:34 -07001966 boolean success = mAppWidgetManager.bindAppWidgetIdIfAllowed(
1967 appWidgetId, info.info, options);
Adam Cohendd70d662012-10-04 16:53:44 -07001968 if (success) {
Sunny Goyal04a324a2017-01-20 21:08:59 -08001969 addAppWidgetFromDropImpl(appWidgetId, info, null, addFlowHandler);
Michael Jurka8b805b12012-04-18 14:23:14 -07001970 } else {
Sunny Goyal04a324a2017-01-20 21:08:59 -08001971 addFlowHandler.startBindFlow(this, appWidgetId, info, REQUEST_BIND_APPWIDGET);
Michael Jurka8b805b12012-04-18 14:23:14 -07001972 }
Adam Cohened66b2b2012-01-23 17:28:51 -08001973 }
Adam Cohenfbba09b2011-07-18 21:43:05 -07001974 }
1975
Samuel Fufa746d4202020-02-02 18:55:44 -08001976 /**
1977 * Creates and adds new folder to CellLayout
1978 */
Samuel Fufa28c3e452020-02-08 16:07:16 -08001979 public FolderIcon addFolder(CellLayout layout, int container, final int screenId, int cellX,
1980 int cellY) {
Michael Jurkac9d95c52011-08-29 14:03:34 -07001981 final FolderInfo folderInfo = new FolderInfo();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001982
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001983 // Update the model
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001984 getModelWriter().addItemToDatabase(folderInfo, container, screenId, cellX, cellY);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001985
1986 // Create the view
Samuel Fufa746d4202020-02-02 18:55:44 -08001987 FolderIcon newFolder = FolderIcon.inflateFolderAndIcon(R.layout.folder_icon, this, layout,
1988 folderInfo);
Sunny Goyald5462aa2016-11-22 16:52:39 +05301989 mWorkspace.addInScreen(newFolder, folderInfo);
Winson Chung5f8afe62013-08-12 16:19:28 -07001990 // Force measure the new folder icon
1991 CellLayout parent = mWorkspace.getParentCellLayoutForView(newFolder);
1992 parent.getShortcutsAndWidgets().measureChild(newFolder);
Adam Cohendf035382011-04-11 17:22:04 -07001993 return newFolder;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001994 }
Romain Guycbb89e42009-06-08 15:52:54 -07001995
Tony Wickham1906cc32021-02-11 11:55:24 -08001996 @Override
1997 public Rect getFolderBoundingBox() {
1998 // We need to bound the folder to the currently visible workspace area
Andras Kloczl3a4ba0b2021-03-29 18:47:14 +02001999 return getWorkspace().getPageAreaRelativeToDragLayer();
Tony Wickham1906cc32021-02-11 11:55:24 -08002000 }
2001
2002 @Override
2003 public void updateOpenFolderPosition(int[] inOutPosition, Rect bounds, int width, int height) {
2004 int left = inOutPosition[0];
2005 int top = inOutPosition[1];
2006 DeviceProfile grid = getDeviceProfile();
2007 int distFromEdgeOfScreen = getWorkspace().getPaddingLeft();
2008 if (grid.isPhone && (grid.availableWidthPx - width) < 4 * distFromEdgeOfScreen) {
2009 // Center the folder if it is very close to being centered anyway, by virtue of
2010 // filling the majority of the viewport. ie. remove it from the uncanny valley
2011 // of centeredness.
2012 left = (grid.availableWidthPx - width) / 2;
2013 } else if (width >= bounds.width()) {
2014 // If the folder doesn't fit within the bounds, center it about the desired bounds
2015 left = bounds.left + (bounds.width() - width) / 2;
2016 }
2017 if (height >= bounds.height()) {
2018 // Folder height is greater than page height, center on page
2019 top = bounds.top + (bounds.height() - height) / 2;
2020 } else {
2021 // Folder height is less than page height, so bound it to the absolute open folder
2022 // bounds if necessary
2023 Rect folderBounds = grid.getAbsoluteOpenFolderBounds();
2024 left = Math.max(folderBounds.left, Math.min(left, folderBounds.right - width));
2025 top = Math.max(folderBounds.top, Math.min(top, folderBounds.bottom - height));
2026 }
2027 inOutPosition[0] = left;
2028 inOutPosition[1] = top;
2029 }
2030
Winsonc0b52fe2015-09-09 16:38:15 -07002031 /**
Winsonfa56b3f2015-09-14 12:01:13 -07002032 * Unbinds the view for the specified item, and removes the item and all its children.
2033 *
2034 * @param v the view being removed.
Winsonfa56b3f2015-09-14 12:01:13 -07002035 * @param itemInfo the {@link ItemInfo} for this view.
2036 * @param deleteFromDb whether or not to delete this item from the db.
Winsonc0b52fe2015-09-09 16:38:15 -07002037 */
Tony Wickhambfbf7f92016-05-19 11:19:39 -07002038 public boolean removeItem(View v, final ItemInfo itemInfo, boolean deleteFromDb) {
Pinyao Ting6a41d562022-05-10 23:47:36 +00002039 return removeItem(v, itemInfo, deleteFromDb, null);
2040 }
2041
2042 /**
2043 * Unbinds the view for the specified item, and removes the item and all its children.
2044 *
2045 * @param v the view being removed.
2046 * @param itemInfo the {@link ItemInfo} for this view.
2047 * @param deleteFromDb whether or not to delete this item from the db.
2048 * @param reason the resaon for removal.
2049 */
2050 public boolean removeItem(View v, final ItemInfo itemInfo, boolean deleteFromDb,
2051 @Nullable final String reason) {
Sunny Goyal95899162019-03-27 16:03:06 -07002052 if (itemInfo instanceof WorkspaceItemInfo) {
Winsonfa56b3f2015-09-14 12:01:13 -07002053 // Remove the shortcut from the folder before removing it from launcher
Sunny Goyal44c06432016-04-02 10:56:02 -07002054 View folderIcon = mWorkspace.getHomescreenIconByItemId(itemInfo.container);
2055 if (folderIcon instanceof FolderIcon) {
Sunny Goyal95899162019-03-27 16:03:06 -07002056 ((FolderInfo) folderIcon.getTag()).remove((WorkspaceItemInfo) itemInfo, true);
Winsonfa56b3f2015-09-14 12:01:13 -07002057 } else {
2058 mWorkspace.removeWorkspaceItem(v);
2059 }
Winsonc0b52fe2015-09-09 16:38:15 -07002060 if (deleteFromDb) {
Pinyao Ting6a41d562022-05-10 23:47:36 +00002061 getModelWriter().deleteItemFromDatabase(itemInfo, reason);
Winsonc0b52fe2015-09-09 16:38:15 -07002062 }
2063 } else if (itemInfo instanceof FolderInfo) {
2064 final FolderInfo folderInfo = (FolderInfo) itemInfo;
Sunny Goyalaaf7d1d2016-05-17 13:38:54 -07002065 if (v instanceof FolderIcon) {
2066 ((FolderIcon) v).removeListeners();
2067 }
Winsonc0b52fe2015-09-09 16:38:15 -07002068 mWorkspace.removeWorkspaceItem(v);
2069 if (deleteFromDb) {
Sunny Goyal43bf11d2017-02-02 13:52:53 -08002070 getModelWriter().deleteFolderAndContentsFromDatabase(folderInfo);
Winsonc0b52fe2015-09-09 16:38:15 -07002071 }
2072 } else if (itemInfo instanceof LauncherAppWidgetInfo) {
2073 final LauncherAppWidgetInfo widgetInfo = (LauncherAppWidgetInfo) itemInfo;
Winson44818e02015-10-02 11:25:46 -07002074 mWorkspace.removeWorkspaceItem(v);
Winsonc0b52fe2015-09-09 16:38:15 -07002075 if (deleteFromDb) {
Sihua Ma0593a0d2022-10-03 16:01:48 -07002076 getModelWriter().deleteWidgetInfo(widgetInfo, getAppWidgetHolder(), reason);
Winsonc0b52fe2015-09-09 16:38:15 -07002077 }
2078 } else {
2079 return false;
2080 }
2081 return true;
2082 }
2083
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002084 @Override
2085 public boolean dispatchKeyEvent(KeyEvent event) {
vadimt6b534ee2021-08-06 15:49:02 -07002086 TestLogging.recordKeyEvent(TestProtocol.SEQUENCE_MAIN, "Key event", event);
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08002087 return (event.getKeyCode() == KeyEvent.KEYCODE_HOME) || super.dispatchKeyEvent(event);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002088 }
2089
Joe Onorato88ec0992009-11-19 13:16:06 -08002090 @Override
vadimt9af34a72020-01-21 11:19:13 -08002091 public boolean dispatchTouchEvent(MotionEvent ev) {
Sunny Goyala306e592020-03-24 01:51:41 -07002092 switch (ev.getAction()) {
2093 case MotionEvent.ACTION_DOWN:
2094 mTouchInProgress = true;
2095 break;
2096 case MotionEvent.ACTION_UP:
Riddle Hsub30adcb2020-10-07 15:57:44 +08002097 mLastTouchUpTime = SystemClock.uptimeMillis();
Sunny Goyala306e592020-03-24 01:51:41 -07002098 // Follow through
2099 case MotionEvent.ACTION_CANCEL:
2100 mTouchInProgress = false;
2101 break;
Sunny Goyal9b180102020-03-11 10:02:29 -07002102 }
vadimtd633c9c2020-01-22 18:00:37 -08002103 TestLogging.recordMotionEvent(TestProtocol.SEQUENCE_MAIN, "Touch event", ev);
vadimt9af34a72020-01-21 11:19:13 -08002104 return super.dispatchTouchEvent(ev);
2105 }
2106
Sunny Goyala306e592020-03-24 01:51:41 -07002107 /**
2108 * Returns true if a touch interaction is in progress
2109 */
2110 public boolean isTouchInProgress() {
2111 return mTouchInProgress;
2112 }
2113
vadimt9af34a72020-01-21 11:19:13 -08002114 @Override
Joe Onorato88ec0992009-11-19 13:16:06 -08002115 public void onBackPressed() {
Fengjiang Li6bb8d792023-01-12 16:20:58 -08002116 getOnBackPressedHandler().onBackInvoked();
Joe Onorato88ec0992009-11-19 13:16:06 -08002117 }
2118
Sunny Goyal3f2637f2022-05-05 12:24:08 -07002119 protected void onStateBack() {
2120 mStateManager.getState().onBackPressed(this);
2121 }
2122
Sunny Goyala992ac92023-01-10 17:50:32 -08002123 protected void onScreenOnChanged(boolean isOn) {
Tracy Zhouf20a4bd2021-04-19 21:37:08 -07002124 // Reset AllApps to its initial state only if we are not in the middle of
2125 // processing a multi-step drop
Sunny Goyala992ac92023-01-10 17:50:32 -08002126 if (!isOn && mPendingRequestArgs == null) {
Tracy Zhouf20a4bd2021-04-19 21:37:08 -07002127 if (!isInState(NORMAL)) {
2128 onUiChangedWhileSleeping();
2129 }
2130 mStateManager.goToState(NORMAL);
2131 }
2132 }
2133
Sunny Goyalfe770c92016-09-27 14:38:58 -07002134 @TargetApi(Build.VERSION_CODES.M)
Sunny Goyal0b0847b2018-03-14 12:30:11 -07002135 @Override
Brian Isganitisbde3c8b2022-03-15 13:35:06 -07002136 public boolean onErrorStartingShortcut(Intent intent, ItemInfo info) {
Sunny Goyal0b0847b2018-03-14 12:30:11 -07002137 // Due to legacy reasons, direct call shortcuts require Launchers to have the
2138 // corresponding permission. Show the appropriate permission prompt if that
2139 // is the case.
2140 if (intent.getComponent() == null
2141 && Intent.ACTION_CALL.equals(intent.getAction())
2142 && checkSelfPermission(android.Manifest.permission.CALL_PHONE) !=
2143 PackageManager.PERMISSION_GRANTED) {
2144
2145 setWaitingForResult(PendingRequestArgs
2146 .forIntent(REQUEST_PERMISSION_CALL_PHONE, intent, info));
2147 requestPermissions(new String[]{android.Manifest.permission.CALL_PHONE},
2148 REQUEST_PERMISSION_CALL_PHONE);
2149 return true;
2150 } else {
2151 return false;
2152 }
Sunny Goyal0eca4e22016-07-20 11:43:06 -07002153 }
2154
Hyunyoung Song46d07f72018-05-22 15:41:25 -07002155 @Override
Sunny Goyal852537f2020-07-15 17:02:16 -07002156 public boolean startActivitySafely(View v, Intent intent, ItemInfo item) {
Winson Chung0b70cd42019-06-17 22:34:33 -07002157 if (!hasBeenResumed()) {
2158 // Workaround an issue where the WM launch animation is clobbered when finishing the
2159 // recents animation into launcher. Defer launching the activity until Launcher is
2160 // next resumed.
Sunny Goyal852537f2020-07-15 17:02:16 -07002161 addOnResumeCallback(() -> startActivitySafely(v, intent, item));
Winson Chungc9bf6d42019-10-04 15:33:18 -07002162 if (mOnDeferredActivityLaunchCallback != null) {
2163 mOnDeferredActivityLaunchCallback.run();
2164 mOnDeferredActivityLaunchCallback = null;
2165 }
Winson Chung0b70cd42019-06-17 22:34:33 -07002166 return true;
2167 }
2168
Sunny Goyal852537f2020-07-15 17:02:16 -07002169 boolean success = super.startActivitySafely(v, intent, item);
Hyunyoung Song1241e612018-05-15 21:46:51 -07002170 if (success && v instanceof BubbleTextView) {
Sunny Goyal0b0847b2018-03-14 12:30:11 -07002171 // This is set to the view that launched the activity that navigated the user away
2172 // from launcher. Since there is no callback for when the activity has finished
2173 // launching, enable the press state and keep this reference to reset the press
2174 // state when we return to launcher.
2175 BubbleTextView btv = (BubbleTextView) v;
2176 btv.setStayPressed(true);
Sunny Goyalb65d7662021-03-07 15:09:11 -08002177 addOnResumeCallback(() -> btv.setStayPressed(false));
Sunny Goyala7ce1662016-05-31 15:01:35 -07002178 }
Hyunyoung Song1241e612018-05-15 21:46:51 -07002179 return success;
Michael Jurka86a720e2012-05-09 11:23:23 -07002180 }
2181
Winson Chung3d503fb2011-07-13 17:25:49 -07002182 boolean isHotseatLayout(View layout) {
Sunny Goyalc13403c2016-11-18 23:44:48 -08002183 // TODO: Remove this method
Sunny Goyal876e4622018-11-02 13:50:40 -07002184 return mHotseat != null && (layout == mHotseat);
Winson Chung3d503fb2011-07-13 17:25:49 -07002185 }
Romain Guy1fbc1c82009-11-09 20:43:08 -08002186
Winson Chung3d503fb2011-07-13 17:25:49 -07002187 /**
2188 * Returns the CellLayout of the specified container at the specified screen.
2189 */
Sunny Goyalefb7e842018-10-04 15:11:00 -07002190 public CellLayout getCellLayout(int container, int screenId) {
Sunny Goyal876e4622018-11-02 13:50:40 -07002191 return (container == LauncherSettings.Favorites.CONTAINER_HOTSEAT)
2192 ? mHotseat : mWorkspace.getScreenWithId(screenId);
Romain Guya6abce82009-11-10 02:54:41 -08002193 }
2194
Michael Jurkae326f182011-11-21 14:05:46 -08002195 @Override
2196 public void onTrimMemory(int level) {
2197 super.onTrimMemory(level);
Adam Cohen3f9c9712014-10-31 11:48:25 -07002198 if (level >= ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN) {
2199 // The widget preview db can result in holding onto over
2200 // 3MB of memory for caching which isn't necessary.
2201 SQLiteDatabase.releaseMemory();
2202
Adam Cohenc8f4e1b2014-11-19 16:03:20 -08002203 // This clears all widget bitmaps from the widget tray
Hyunyoung Song3f471442015-04-08 19:01:34 -07002204 // TODO(hyunyoungs)
Michael Jurkae326f182011-11-21 14:05:46 -08002205 }
2206 }
2207
Michael Jurkad7c28052012-04-27 15:43:36 -07002208 @Override
2209 public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
alanv1d4fde62012-10-17 13:15:47 -07002210 final boolean result = super.dispatchPopulateAccessibilityEvent(event);
Michael Jurkad7c28052012-04-27 15:43:36 -07002211 final List<CharSequence> text = event.getText();
2212 text.clear();
alanv1d4fde62012-10-17 13:15:47 -07002213 // Populate event with a fake title based on the current state.
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07002214 // TODO: When can workspace be null?
2215 text.add(mWorkspace == null
Sunny Goyal52e25452020-07-20 12:38:01 -07002216 ? getString(R.string.home_screen)
Sunny Goyalea609262017-10-25 15:47:38 -07002217 : mStateManager.getState().getDescription(this));
Michael Jurkad7c28052012-04-27 15:43:36 -07002218 return result;
2219 }
2220
Michael Jurka7607c2f2013-04-03 14:33:19 -07002221 /**
Winson Chungc9bf6d42019-10-04 15:33:18 -07002222 * Persistant callback which notifies when an activity launch is deferred because the activity
2223 * was not yet resumed.
2224 */
2225 public void setOnDeferredActivityLaunchCallback(Runnable callback) {
2226 mOnDeferredActivityLaunchCallback = callback;
2227 }
2228
2229 /**
Andras Kloczl55edfe52021-05-14 12:21:30 +02002230 * Sets the next pages to bind synchronously on next bind.
2231 * @param pages should not be null.
Sunny Goyala7a5bf32020-01-05 15:35:29 +05302232 */
Andras Kloczl55edfe52021-05-14 12:21:30 +02002233 public void setPagesToBindSynchronously(@NonNull IntSet pages) {
2234 mPagesToBindSynchronously = pages;
Sunny Goyala7a5bf32020-01-05 15:35:29 +05302235 }
2236
Sunny Goyal93f878c2016-03-30 17:31:24 -07002237 @Override
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002238 public IntSet getPagesToBindSynchronously(IntArray orderedScreenIds) {
Alex Chau49354042021-08-25 13:21:58 +01002239 IntSet visibleIds;
2240 if (!mPagesToBindSynchronously.isEmpty()) {
2241 visibleIds = mPagesToBindSynchronously;
2242 } else if (!mWorkspaceLoading) {
2243 visibleIds = mWorkspace.getCurrentPageScreenIds();
2244 } else {
2245 // If workspace binding is still in progress, getCurrentPageScreenIds won't be accurate,
2246 // and we should use mSynchronouslyBoundPages that's set during initial binding.
2247 visibleIds = mSynchronouslyBoundPages;
2248 }
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002249 IntArray actualIds = new IntArray();
2250
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002251 IntSet result = new IntSet();
2252 if (visibleIds.isEmpty()) {
Schneider Victor-tulias00213382021-09-27 13:41:10 -07002253 if (TestProtocol.sDebugTracing) {
2254 Log.d(TestProtocol.NULL_INT_SET, "getPagesToBindSynchronously (1): "
2255 + result);
2256 }
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002257 return result;
2258 }
2259 for (int id : orderedScreenIds.toArray()) {
Alex Chau1e448462021-08-13 21:48:35 +01002260 actualIds.add(id);
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002261 }
2262 int firstId = visibleIds.getArray().get(0);
Steven Ng4b346102021-09-14 19:17:09 +01002263 int pairId = mWorkspace.getScreenPair(firstId);
Alex Chau62f129b2021-09-03 16:54:27 +01002264 // Double check that actual screenIds contains the visibleId, as empty screens are hidden
2265 // in single panel.
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002266 if (actualIds.contains(firstId)) {
2267 result.add(firstId);
Alex Chau62f129b2021-09-03 16:54:27 +01002268 if (mDeviceProfile.isTwoPanels && actualIds.contains(pairId)) {
2269 result.add(pairId);
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002270 }
Alex Chau62f129b2021-09-03 16:54:27 +01002271 } else if (LauncherAppState.getIDP(this).supportedProfiles.stream().anyMatch(
2272 deviceProfile -> deviceProfile.isTwoPanels) && actualIds.contains(pairId)) {
2273 // Add the right panel if left panel is hidden when switching display, due to empty
2274 // pages being hidden in single panel.
2275 result.add(pairId);
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002276 }
Schneider Victor-tulias00213382021-09-27 13:41:10 -07002277 if (TestProtocol.sDebugTracing) {
2278 Log.d(TestProtocol.NULL_INT_SET, "getPagesToBindSynchronously (2): "
2279 + result);
2280 }
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002281 return result;
Joe Onorato9c1289c2009-08-17 11:03:03 -04002282 }
The Android Open Source Projectf96811c2009-03-18 17:39:48 -07002283
Joe Onorato9c1289c2009-08-17 11:03:03 -04002284 /**
Sunny Goyal527c7d32015-08-28 15:19:36 -07002285 * Clear any pending bind callbacks. This is called when is loader is planning to
2286 * perform a full rebind from scratch.
2287 */
2288 @Override
2289 public void clearPendingBinds() {
Sunny Goyal527c7d32015-08-28 15:19:36 -07002290 if (mPendingExecutor != null) {
Sunny Goyal4a48a982021-06-17 15:15:46 -07002291 mPendingExecutor.cancel();
Sunny Goyal527c7d32015-08-28 15:19:36 -07002292 mPendingExecutor = null;
Sunny Goyal6b6d0a32019-08-05 17:19:32 -07002293
2294 // We might have set this flag previously and forgot to clear it.
2295 mAppsView.getAppsStore()
2296 .disableDeferUpdatesSilently(AllAppsStore.DEFER_UPDATES_NEXT_DRAW);
Sunny Goyal527c7d32015-08-28 15:19:36 -07002297 }
2298 }
2299
2300 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04002301 * Refreshes the shortcuts shown on the workspace.
2302 *
2303 * Implementation of the method from LauncherModel.Callbacks.
2304 */
2305 public void startBinding() {
Winson Chung5cc62c72019-10-16 11:32:41 -07002306 Object traceToken = TraceHelper.INSTANCE.beginSection("startBinding");
Schneider Victor-tulias6b94a962023-02-22 12:08:21 -08002307 if (TestProtocol.sDebugTracing) {
2308 Log.d(TestProtocol.FLAKY_BINDING, "running: startBinding");
2309 }
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07002310 // Floating panels (except the full widget sheet) are associated with individual icons. If
2311 // we are starting a fresh bind, close all such panels as all the icons are about
2312 // to go away.
Pinyao Tinga74b63a2019-07-17 23:26:06 -07002313 AbstractFloatingView.closeOpenViews(this, true, TYPE_ALL & ~TYPE_REBIND_SAFE);
Jon Miranda6dc7f1e2017-02-21 12:37:51 -08002314
Anjali Koppalff7ceff2014-05-01 18:26:37 -07002315 setWorkspaceLoading(true);
Adam Cohen517a7f52014-03-01 12:12:59 -08002316
Winson Chungd64d1762013-08-20 14:37:16 -07002317 // Clear the workspace because it's going to be rebound
Sunny Goyal2db53422019-03-01 16:06:12 -08002318 mDragController.cancelDrag();
2319
Adam Cohendf035382011-04-11 17:22:04 -07002320 mWorkspace.clearDropTargets();
Winson Chung9e6a0a22013-08-27 11:58:12 -07002321 mWorkspace.removeAllWorkspaceScreens();
Sihua Ma0593a0d2022-10-03 16:01:48 -07002322 mAppWidgetHolder.clearViews();
Winson Chungd64d1762013-08-20 14:37:16 -07002323
Winson Chung3d503fb2011-07-13 17:25:49 -07002324 if (mHotseat != null) {
Sunny Goyalc4d32012020-04-03 17:10:11 -07002325 mHotseat.resetLayout(getDeviceProfile().isVerticalBarLayout());
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002326 }
Winson Chung5cc62c72019-10-16 11:32:41 -07002327 TraceHelper.INSTANCE.endSection(traceToken);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002328 }
2329
Adam Cohendcd297f2013-06-18 13:13:40 -07002330 @Override
Sunny Goyalefb7e842018-10-04 15:11:00 -07002331 public void bindScreens(IntArray orderedScreenIds) {
Alex Chau1e448462021-08-13 21:48:35 +01002332 int firstScreenPosition = 0;
Jon Miranda7143ba62019-03-15 09:00:05 -07002333 if (FeatureFlags.QSB_ON_FIRST_SCREEN &&
Andras Kloczldbf577a2021-05-26 15:02:52 +02002334 orderedScreenIds.indexOf(Workspace.FIRST_SCREEN_ID) != firstScreenPosition) {
Sunny Goyalefb7e842018-10-04 15:11:00 -07002335 orderedScreenIds.removeValue(Workspace.FIRST_SCREEN_ID);
Andras Kloczldbf577a2021-05-26 15:02:52 +02002336 orderedScreenIds.add(firstScreenPosition, Workspace.FIRST_SCREEN_ID);
Jon Miranda7143ba62019-03-15 09:00:05 -07002337 } else if (!FeatureFlags.QSB_ON_FIRST_SCREEN && orderedScreenIds.isEmpty()) {
Sunny Goyala9e2f5a2016-06-10 12:22:04 -07002338 // If there are no screens, we need to have an empty screen
Andras Kloczl408a54f2021-08-28 00:59:08 +01002339 mWorkspace.addExtraEmptyScreens();
Adam Cohen5084cba2013-09-03 12:01:16 -07002340 }
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002341 bindAddScreens(orderedScreenIds);
Winson Chung0e6a7132013-08-23 12:55:10 -07002342
Winsonc7d2e832016-07-28 12:24:55 -07002343 // After we have added all the screens, if the wallpaper was locked to the default state,
2344 // then notify to indicate that it can be released and a proper wallpaper offset can be
2345 // computed before the next layout
2346 mWorkspace.unlockWallpaperFromDefaultPageOnNextLayout();
Winson Chung64359a52013-07-08 17:17:08 -07002347 }
2348
Sunny Goyalefb7e842018-10-04 15:11:00 -07002349 private void bindAddScreens(IntArray orderedScreenIds) {
Andras Kloczl8c574de2021-08-17 23:12:17 +02002350 if (mDeviceProfile.isTwoPanels) {
2351 // Some empty pages might have been removed while the phone was in a single panel
2352 // mode, so we want to add those empty pages back.
2353 IntSet screenIds = IntSet.wrap(orderedScreenIds);
Steven Ng4b346102021-09-14 19:17:09 +01002354 orderedScreenIds.forEach(screenId -> screenIds.add(mWorkspace.getScreenPair(screenId)));
Andras Kloczl8c574de2021-08-17 23:12:17 +02002355 orderedScreenIds = screenIds.getArray();
2356 }
2357
Adam Cohendcd297f2013-06-18 13:13:40 -07002358 int count = orderedScreenIds.size();
2359 for (int i = 0; i < count; i++) {
Sunny Goyalefb7e842018-10-04 15:11:00 -07002360 int screenId = orderedScreenIds.get(i);
Andras Kloczldbf577a2021-05-26 15:02:52 +02002361 if (FeatureFlags.QSB_ON_FIRST_SCREEN && screenId == Workspace.FIRST_SCREEN_ID) {
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002362 // No need to bind the first screen, as its always bound.
Andras Kloczldbf577a2021-05-26 15:02:52 +02002363 continue;
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002364 }
Andras Kloczldbf577a2021-05-26 15:02:52 +02002365 mWorkspace.insertNewWorkspaceScreenBeforeEmptyScreen(screenId);
Adam Cohendcd297f2013-06-18 13:13:40 -07002366 }
Adam Cohendcd297f2013-06-18 13:13:40 -07002367 }
2368
Sunny Goyalb23980c2017-08-17 07:45:25 -07002369 @Override
Tony Wickham6a71a5b2018-08-21 11:40:23 -07002370 public void preAddApps() {
2371 // If there's an undo snackbar, force it to complete to ensure empty screens are removed
2372 // before trying to add new items.
2373 mModelWriter.commitDelete();
2374 AbstractFloatingView snackbar = AbstractFloatingView.getOpenView(this, TYPE_SNACKBAR);
2375 if (snackbar != null) {
2376 snackbar.post(() -> snackbar.close(true));
2377 }
2378 }
2379
2380 @Override
Sunny Goyalefb7e842018-10-04 15:11:00 -07002381 public void bindAppsAdded(IntArray newScreens, ArrayList<ItemInfo> addNotAnimated,
Sunny Goyal29947f02017-12-18 13:49:44 -08002382 ArrayList<ItemInfo> addAnimated) {
Winson Chungd64d1762013-08-20 14:37:16 -07002383 // Add the new screens
Adam Cohen76a47a12014-02-05 11:47:43 -08002384 if (newScreens != null) {
Alex Chau817e0fa2021-09-08 20:46:32 +01002385 // newScreens can contain an empty right panel that is already bound, but not known
2386 // by BgDataModel.
2387 newScreens.removeAllValues(mWorkspace.mScreenOrder);
Adam Cohen76a47a12014-02-05 11:47:43 -08002388 bindAddScreens(newScreens);
2389 }
Winson Chungd64d1762013-08-20 14:37:16 -07002390
2391 // We add the items without animation on non-visible pages, and with
2392 // animations on the new page (which we will try and snap to).
Adam Cohen76a47a12014-02-05 11:47:43 -08002393 if (addNotAnimated != null && !addNotAnimated.isEmpty()) {
Sunny Goyalb23980c2017-08-17 07:45:25 -07002394 bindItems(addNotAnimated, false);
Winson Chungd64d1762013-08-20 14:37:16 -07002395 }
Adam Cohen76a47a12014-02-05 11:47:43 -08002396 if (addAnimated != null && !addAnimated.isEmpty()) {
Sunny Goyalb23980c2017-08-17 07:45:25 -07002397 bindItems(addAnimated, true);
Winson Chungd64d1762013-08-20 14:37:16 -07002398 }
Winson Chungc58497e2013-09-03 17:48:37 -07002399
Winson Chung87412982013-10-03 18:34:14 -07002400 // Remove the extra empty screen
Sunny Goyal6e379fc2020-03-19 16:08:14 -07002401 mWorkspace.removeExtraEmptyScreen(false);
Winson Chungd64d1762013-08-20 14:37:16 -07002402 }
2403
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002404 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04002405 * Bind the items start-end from the list.
2406 *
2407 * Implementation of the method from LauncherModel.Callbacks.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002408 */
Tony Wickham0bb211a2015-10-02 16:22:08 -07002409 @Override
Sunny Goyalb23980c2017-08-17 07:45:25 -07002410 public void bindItems(final List<ItemInfo> items, final boolean forceAnimateIcons) {
Schneider Victor-tulias68706eb2021-04-29 15:24:54 -07002411 bindItems(items, forceAnimateIcons, /* focusFirstItemForAccessibility= */ false);
2412 }
2413
2414
2415 /**
2416 * Bind the items start-end from the list.
2417 *
2418 * Implementation of the method from LauncherModel.Callbacks.
2419 *
2420 * @param focusFirstItemForAccessibility true iff the first item to be added to the workspace
2421 * should be focused for accessibility.
2422 */
2423 public void bindItems(
2424 final List<ItemInfo> items,
2425 final boolean forceAnimateIcons,
2426 final boolean focusFirstItemForAccessibility) {
Sunny Goyal3be633b2016-12-08 09:59:25 -08002427 // Get the list of added items and intersect them with the set of items here
Rajeev Kumar43c0f582017-06-23 15:34:55 -07002428 final Collection<Animator> bounceAnims = new ArrayList<>();
Schneider Victor-tulias68fb4162021-09-16 13:24:01 -07002429 boolean canAnimatePageChange = canAnimatePageChange();
Shikha Malhotraf78da1b2022-04-11 10:23:18 +00002430 Workspace<?> workspace = mWorkspace;
Sunny Goyalefb7e842018-10-04 15:11:00 -07002431 int newItemsScreenId = -1;
Sunny Goyalb23980c2017-08-17 07:45:25 -07002432 int end = items.size();
Schneider Victor-tulias68706eb2021-04-29 15:24:54 -07002433 View newView = null;
Sunny Goyalb23980c2017-08-17 07:45:25 -07002434 for (int i = 0; i < end; i++) {
Sunny Goyal3be633b2016-12-08 09:59:25 -08002435 final ItemInfo item = items.get(i);
Winson Chung4d279d92011-07-21 11:46:32 -07002436
2437 // Short circuit if we are loading dock items for a configuration which has no dock
2438 if (item.container == LauncherSettings.Favorites.CONTAINER_HOTSEAT &&
2439 mHotseat == null) {
2440 continue;
2441 }
2442
Sunny Goyal639e9062015-08-19 19:17:06 -07002443 final View view;
Joe Onorato9c1289c2009-08-17 11:03:03 -04002444 switch (item.itemType) {
2445 case LauncherSettings.Favorites.ITEM_TYPE_APPLICATION:
2446 case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT:
Sunny Goyal3be633b2016-12-08 09:59:25 -08002447 case LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT: {
Sunny Goyal95899162019-03-27 16:03:06 -07002448 WorkspaceItemInfo info = (WorkspaceItemInfo) item;
Sunny Goyal639e9062015-08-19 19:17:06 -07002449 view = createShortcut(info);
Joe Onorato9c1289c2009-08-17 11:03:03 -04002450 break;
Sunny Goyal3be633b2016-12-08 09:59:25 -08002451 }
2452 case LauncherSettings.Favorites.ITEM_TYPE_FOLDER: {
Tracy Zhou4d7b2442019-12-09 13:42:57 -08002453 view = FolderIcon.inflateFolderAndIcon(R.layout.folder_icon, this,
Michael Jurka0142d492010-08-25 17:46:15 -07002454 (ViewGroup) workspace.getChildAt(workspace.getCurrentPage()),
Sunny Goyal1cd01b02016-11-09 10:43:58 -08002455 (FolderInfo) item);
Joe Onorato9c1289c2009-08-17 11:03:03 -04002456 break;
Sunny Goyal3be633b2016-12-08 09:59:25 -08002457 }
Sunny Goyal952e63d2017-08-16 04:59:08 -07002458 case LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET:
2459 case LauncherSettings.Favorites.ITEM_TYPE_CUSTOM_APPWIDGET: {
Sunny Goyala9a1a212017-08-18 01:03:21 -07002460 view = inflateAppWidget((LauncherAppWidgetInfo) item);
Sunny Goyalb23980c2017-08-17 07:45:25 -07002461 if (view == null) {
2462 continue;
Sunny Goyal3be633b2016-12-08 09:59:25 -08002463 }
Sunny Goyal3be633b2016-12-08 09:59:25 -08002464 break;
2465 }
Winson Chungc763c4e2013-07-19 13:49:06 -07002466 default:
2467 throw new RuntimeException("Invalid Item Type");
Joe Onorato9c1289c2009-08-17 11:03:03 -04002468 }
Sunny Goyal639e9062015-08-19 19:17:06 -07002469
Samuel Fufaca37b8a2019-08-19 17:04:36 -07002470 /*
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002471 * Remove colliding items.
2472 */
Sunny Goyal669b71f2023-01-27 14:37:07 -08002473 CellPos presenterPos = getCellPosMapper().mapModelToPresenter(item);
2474 if (item.container == CONTAINER_DESKTOP) {
2475 CellLayout cl = mWorkspace.getScreenWithId(presenterPos.screenId);
2476 if (cl != null && cl.isOccupied(presenterPos.cellX, presenterPos.cellY)) {
2477 View v = cl.getChildAt(presenterPos.cellX, presenterPos.cellY);
Jon Miranda0aff1152021-11-05 16:36:07 -07002478 if (v == null) {
2479 Log.e(TAG, "bindItems failed when removing colliding item=" + item);
2480 }
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002481 Object tag = v.getTag();
2482 String desc = "Collision while binding workspace item: " + item
2483 + ". Collides with " + tag;
Zak Cohen3eeb41d2020-02-14 14:15:13 -08002484 if (FeatureFlags.IS_STUDIO_BUILD) {
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002485 throw (new RuntimeException(desc));
2486 } else {
Pinyao Ting6a41d562022-05-10 23:47:36 +00002487 getModelWriter().deleteItemFromDatabase(item, desc);
Jon Miranda701774d2022-02-10 11:09:04 -08002488 if (TestProtocol.sDebugTracing) {
2489 Log.d(TestProtocol.MISSING_PROMISE_ICON,
2490 TAG + "bindItems failed for item=" + item);
2491 }
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002492 continue;
2493 }
2494 }
2495 }
Sunny Goyald5462aa2016-11-22 16:52:39 +05302496 workspace.addInScreenFromBind(view, item);
Schneider Victor-tulias68fb4162021-09-16 13:24:01 -07002497 if (forceAnimateIcons) {
Sunny Goyal639e9062015-08-19 19:17:06 -07002498 // Animate all the applications up now
2499 view.setAlpha(0f);
2500 view.setScaleX(0f);
2501 view.setScaleY(0f);
2502 bounceAnims.add(createNewAppBounceAnimation(view, i));
Sunny Goyal669b71f2023-01-27 14:37:07 -08002503 newItemsScreenId = presenterPos.screenId;
Sunny Goyal639e9062015-08-19 19:17:06 -07002504 }
Schneider Victor-tulias68706eb2021-04-29 15:24:54 -07002505
2506 if (newView == null) {
2507 newView = view;
2508 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002509 }
Winson Chungf0c6ae02012-03-21 16:10:31 -07002510
Schneider Victor-tulias68706eb2021-04-29 15:24:54 -07002511 View viewToFocus = newView;
2512 // Animate to the correct pager
Schneider Victor-tulias68fb4162021-09-16 13:24:01 -07002513 if (forceAnimateIcons && newItemsScreenId > -1) {
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002514 AnimatorSet anim = new AnimatorSet();
2515 anim.playTogether(bounceAnims);
Schneider Victor-tulias68706eb2021-04-29 15:24:54 -07002516 if (focusFirstItemForAccessibility && viewToFocus != null) {
2517 anim.addListener(new AnimatorListenerAdapter() {
2518 @Override
2519 public void onAnimationEnd(Animator animation) {
2520 viewToFocus.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_FOCUSED);
2521 }
2522 });
2523 }
Jon Miranda64eb8ea2018-03-29 11:43:58 -07002524
Sunny Goyalefb7e842018-10-04 15:11:00 -07002525 int currentScreenId = mWorkspace.getScreenIdForPageIndex(mWorkspace.getNextPage());
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002526 final int newScreenIndex = mWorkspace.getPageIndexForScreenId(newItemsScreenId);
2527 final Runnable startBounceAnimRunnable = anim::start;
2528
Schneider Victor-tulias68fb4162021-09-16 13:24:01 -07002529 if (canAnimatePageChange && newItemsScreenId != currentScreenId) {
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002530 // We post the animation slightly delayed to prevent slowdowns
2531 // when we are loading right after we return to launcher.
2532 mWorkspace.postDelayed(new Runnable() {
2533 public void run() {
2534 if (mWorkspace != null) {
Andy Wickham65ced1b2020-03-07 02:14:19 +00002535 closeOpenViews(false);
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002536
2537 mWorkspace.snapToPage(newScreenIndex);
2538 mWorkspace.postDelayed(startBounceAnimRunnable,
2539 NEW_APPS_ANIMATION_DELAY);
Winson Chung94d67682013-09-25 16:29:40 -07002540 }
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002541 }
2542 }, NEW_APPS_PAGE_MOVE_DELAY);
2543 } else {
2544 mWorkspace.postDelayed(startBounceAnimRunnable, NEW_APPS_ANIMATION_DELAY);
Winson Chung997a9232013-07-24 15:33:46 -07002545 }
Schneider Victor-tulias68706eb2021-04-29 15:24:54 -07002546 } else if (focusFirstItemForAccessibility && viewToFocus != null) {
2547 viewToFocus.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_FOCUSED);
Winson Chung64359a52013-07-08 17:17:08 -07002548 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04002549 workspace.requestLayout();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002550 }
2551
Joe Onorato9c1289c2009-08-17 11:03:03 -04002552 /**
2553 * Add the views for a widget to the workspace.
Joe Onorato9c1289c2009-08-17 11:03:03 -04002554 */
Sunny Goyala9a1a212017-08-18 01:03:21 -07002555 public void bindAppWidget(LauncherAppWidgetInfo item) {
2556 View view = inflateAppWidget(item);
2557 if (view != null) {
2558 mWorkspace.addInScreen(view, item);
2559 mWorkspace.requestLayout();
2560 }
2561 }
2562
2563 private View inflateAppWidget(LauncherAppWidgetInfo item) {
Samuel Fufaca37b8a2019-08-19 17:04:36 -07002564 if (item.hasOptionFlag(LauncherAppWidgetInfo.OPTION_SEARCH_WIDGET)) {
2565 item.providerName = QsbContainerView.getSearchComponentName(this);
2566 if (item.providerName == null) {
Pinyao Ting6a41d562022-05-10 23:47:36 +00002567 getModelWriter().deleteItemFromDatabase(item,
2568 "search widget removed because search component cannot be found");
Samuel Fufaca37b8a2019-08-19 17:04:36 -07002569 return null;
2570 }
2571 }
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002572 final AppWidgetHostView view;
Sunny Goyal2e1efb42016-03-03 16:58:55 -08002573 if (mIsSafeModeEnabled) {
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002574 view = new PendingAppWidgetHostView(this, item, mIconCache, true);
Sunny Goyald5462aa2016-11-22 16:52:39 +05302575 prepareAppWidget(view, item);
Sunny Goyalb23980c2017-08-17 07:45:25 -07002576 return view;
Sunny Goyal2e1efb42016-03-03 16:58:55 -08002577 }
2578
Winson Chung5cc62c72019-10-16 11:32:41 -07002579 Object traceToken = TraceHelper.INSTANCE.beginSection("BIND_WIDGET_id=" + item.appWidgetId);
Joe Onorato9c1289c2009-08-17 11:03:03 -04002580
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002581 try {
2582 final LauncherAppWidgetProviderInfo appWidgetInfo;
Steven Ngacd9d792021-06-25 11:51:44 +01002583 String removalReason = "";
Adam Cohen59400422014-03-05 18:07:04 -08002584
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002585 if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY)) {
2586 // If the provider is not ready, bind as a pending widget.
2587 appWidgetInfo = null;
Steven Ngacd9d792021-06-25 11:51:44 +01002588 removalReason = "the provider isn't ready.";
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002589 } else if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)) {
2590 // The widget id is not valid. Try to find the widget based on the provider info.
2591 appWidgetInfo = mAppWidgetManager.findProvider(item.providerName, item.user);
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002592 if (appWidgetInfo == null) {
2593 if (WidgetsModel.GO_DISABLE_WIDGETS) {
Steven Ngacd9d792021-06-25 11:51:44 +01002594 removalReason = "widgets are disabled on go device.";
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002595 } else {
Steven Ngacd9d792021-06-25 11:51:44 +01002596 removalReason =
2597 "WidgetManagerHelper cannot find a provider from provider info.";
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002598 }
2599 }
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002600 } else {
2601 appWidgetInfo = mAppWidgetManager.getLauncherAppWidgetInfo(item.appWidgetId);
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002602 if (appWidgetInfo == null) {
2603 if (item.appWidgetId <= LauncherAppWidgetInfo.CUSTOM_WIDGET_ID) {
Steven Ngacd9d792021-06-25 11:51:44 +01002604 removalReason =
2605 "CustomWidgetManager cannot find provider from that widget id.";
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002606 } else {
Steven Ngacd9d792021-06-25 11:51:44 +01002607 removalReason = "AppWidgetManager cannot find provider for that widget id."
2608 + " It could be because AppWidgetService is not available, or the"
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002609 + " appWidgetId has not been bound to a the provider yet, or you"
2610 + " don't have access to that appWidgetId.";
2611 }
2612 }
Sunny Goyalff572272014-07-23 13:58:07 -07002613 }
Sunny Goyalff572272014-07-23 13:58:07 -07002614
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002615 // If the provider is ready, but the width is not yet restored, try to restore it.
2616 if (!item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY)
2617 && (item.restoreStatus != LauncherAppWidgetInfo.RESTORE_COMPLETED)) {
2618 if (appWidgetInfo == null) {
Pinyao Ting6a41d562022-05-10 23:47:36 +00002619 getModelWriter().deleteItemFromDatabase(item,
2620 "Removing restored widget: id=" + item.appWidgetId
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002621 + " belongs to component " + item.providerName + " user " + item.user
Steven Ngacd9d792021-06-25 11:51:44 +01002622 + ", as the provider is null and " + removalReason);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002623 return null;
2624 }
Sunny Goyalff572272014-07-23 13:58:07 -07002625
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002626 // If we do not have a valid id, try to bind an id.
2627 if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)) {
2628 if (!item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_ALLOCATED)) {
2629 // Id has not been allocated yet. Allocate a new id.
Sihua Ma0593a0d2022-10-03 16:01:48 -07002630 item.appWidgetId = mAppWidgetHolder.allocateAppWidgetId();
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002631 item.restoreStatus |= LauncherAppWidgetInfo.FLAG_ID_ALLOCATED;
Sunny Goyal86df1382016-08-10 15:03:22 -07002632
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002633 // Also try to bind the widget. If the bind fails, the user will be shown
2634 // a click to setup UI, which will ask for the bind permission.
Yogisha Dixit658c5da2021-05-24 23:23:15 +01002635 PendingAddWidgetInfo pendingInfo =
2636 new PendingAddWidgetInfo(appWidgetInfo, item.sourceContainer);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002637 pendingInfo.spanX = item.spanX;
2638 pendingInfo.spanY = item.spanY;
2639 pendingInfo.minSpanX = item.minSpanX;
2640 pendingInfo.minSpanY = item.minSpanY;
Sunny Goyal19ff7282021-04-22 10:12:54 -07002641 Bundle options = pendingInfo.getDefaultSizeOptions(this);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002642
2643 boolean isDirectConfig =
2644 item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_DIRECT_CONFIG);
2645 if (isDirectConfig && item.bindOptions != null) {
2646 Bundle newOptions = item.bindOptions.getExtras();
2647 if (options != null) {
2648 newOptions.putAll(options);
2649 }
2650 options = newOptions;
Sunny Goyal86df1382016-08-10 15:03:22 -07002651 }
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002652 boolean success = mAppWidgetManager.bindAppWidgetIdIfAllowed(
2653 item.appWidgetId, appWidgetInfo, options);
2654
2655 // We tried to bind once. If we were not able to bind, we would need to
2656 // go through the permission dialog, which means we cannot skip the config
2657 // activity.
2658 item.bindOptions = null;
2659 item.restoreStatus &= ~LauncherAppWidgetInfo.FLAG_DIRECT_CONFIG;
2660
2661 // Bind succeeded
2662 if (success) {
2663 // If the widget has a configure activity, it is still needs to set it
2664 // up, otherwise the widget is ready to go.
2665 item.restoreStatus = (appWidgetInfo.configure == null) || isDirectConfig
2666 ? LauncherAppWidgetInfo.RESTORE_COMPLETED
2667 : LauncherAppWidgetInfo.FLAG_UI_NOT_READY;
2668 }
2669
2670 getModelWriter().updateItemInDatabase(item);
Sunny Goyal86df1382016-08-10 15:03:22 -07002671 }
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002672 } else if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_UI_NOT_READY)
2673 && (appWidgetInfo.configure == null)) {
2674 // The widget was marked as UI not ready, but there is no configure activity to
2675 // update the UI.
2676 item.restoreStatus = LauncherAppWidgetInfo.RESTORE_COMPLETED;
Sunny Goyal43bf11d2017-02-02 13:52:53 -08002677 getModelWriter().updateItemInDatabase(item);
Sunny Goyalff572272014-07-23 13:58:07 -07002678 }
Samuel Fufa9151c012020-02-24 17:06:28 -08002679 else if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_UI_NOT_READY)
2680 && appWidgetInfo.configure != null) {
2681 if (mAppWidgetManager.isAppWidgetRestored(item.appWidgetId)) {
2682 item.restoreStatus = LauncherAppWidgetInfo.RESTORE_COMPLETED;
2683 getModelWriter().updateItemInDatabase(item);
2684 }
2685 }
Sunny Goyal56c73602015-09-25 12:55:01 -07002686 }
2687
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002688 if (item.restoreStatus == LauncherAppWidgetInfo.RESTORE_COMPLETED) {
2689 // Verify that we own the widget
2690 if (appWidgetInfo == null) {
Pinyao Ting0d97f8d2020-12-04 15:12:26 -08002691 FileLog.e(TAG, "Removing invalid widget: id=" + item.appWidgetId);
Sihua Ma0593a0d2022-10-03 16:01:48 -07002692 getModelWriter().deleteWidgetInfo(item, getAppWidgetHolder(), removalReason);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002693 return null;
2694 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04002695
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002696 item.minSpanX = appWidgetInfo.minSpanX;
2697 item.minSpanY = appWidgetInfo.minSpanY;
Sihua Ma0593a0d2022-10-03 16:01:48 -07002698 view = mAppWidgetHolder.createView(this, item.appWidgetId, appWidgetInfo);
Samuel Fufa9151c012020-02-24 17:06:28 -08002699 } else if (!item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)
2700 && appWidgetInfo != null) {
Sihua Ma0593a0d2022-10-03 16:01:48 -07002701 mAppWidgetHolder.addPendingView(item.appWidgetId,
Samuel Fufa9151c012020-02-24 17:06:28 -08002702 new PendingAppWidgetHostView(this, item, mIconCache, false));
Sihua Ma0593a0d2022-10-03 16:01:48 -07002703 view = mAppWidgetHolder.createView(this, item.appWidgetId, appWidgetInfo);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002704 } else {
2705 view = new PendingAppWidgetHostView(this, item, mIconCache, false);
2706 }
2707 prepareAppWidget(view, item);
2708 } finally {
Winson Chung5cc62c72019-10-16 11:32:41 -07002709 TraceHelper.INSTANCE.endSection(traceToken);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002710 }
2711
Sunny Goyalb23980c2017-08-17 07:45:25 -07002712 return view;
Joe Onorato9c1289c2009-08-17 11:03:03 -04002713 }
2714
Sunny Goyalff572272014-07-23 13:58:07 -07002715 /**
2716 * Restores a pending widget.
2717 *
2718 * @param appWidgetId The app widget id
Sunny Goyalff572272014-07-23 13:58:07 -07002719 */
Sunny Goyald478c832016-04-01 12:04:16 -07002720 private LauncherAppWidgetInfo completeRestoreAppWidget(int appWidgetId, int finalRestoreFlag) {
Sunny Goyalff572272014-07-23 13:58:07 -07002721 LauncherAppWidgetHostView view = mWorkspace.getWidgetForAppWidgetId(appWidgetId);
2722 if ((view == null) || !(view instanceof PendingAppWidgetHostView)) {
2723 Log.e(TAG, "Widget update called, when the widget no longer exists.");
Sunny Goyald478c832016-04-01 12:04:16 -07002724 return null;
Sunny Goyalff572272014-07-23 13:58:07 -07002725 }
2726
Sunny Goyal0fc1be12014-08-11 17:05:23 -07002727 LauncherAppWidgetInfo info = (LauncherAppWidgetInfo) view.getTag();
Sunny Goyald478c832016-04-01 12:04:16 -07002728 info.restoreStatus = finalRestoreFlag;
Jon Miranda2b823f42017-05-02 18:36:18 -07002729 if (info.restoreStatus == LauncherAppWidgetInfo.RESTORE_COMPLETED) {
2730 info.pendingItemInfo = null;
2731 }
Sunny Goyalff572272014-07-23 13:58:07 -07002732
Sunny Goyalba47faa2017-10-04 16:50:57 -07002733 if (((PendingAppWidgetHostView) view).isReinflateIfNeeded()) {
Sunny Goyal29947f02017-12-18 13:49:44 -08002734 view.reInflate();
Sunny Goyalba47faa2017-10-04 16:50:57 -07002735 }
2736
Sunny Goyal43bf11d2017-02-02 13:52:53 -08002737 getModelWriter().updateItemInDatabase(info);
Sunny Goyald478c832016-04-01 12:04:16 -07002738 return info;
Sunny Goyalff572272014-07-23 13:58:07 -07002739 }
2740
Sunny Goyal527c7d32015-08-28 15:19:36 -07002741 public void clearPendingExecutor(ViewOnDrawExecutor executor) {
2742 if (mPendingExecutor == executor) {
2743 mPendingExecutor = null;
2744 }
2745 }
2746
Sunny Goyalb5b9ad62016-04-02 11:23:39 -07002747 @Override
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -07002748 @TargetApi(Build.VERSION_CODES.S)
Sunny Goyal4a48a982021-06-17 15:15:46 -07002749 public void onInitialBindComplete(IntSet boundPages, RunnableList pendingTasks) {
2750 mSynchronouslyBoundPages = boundPages;
Sunny Goyal4a48a982021-06-17 15:15:46 -07002751 mPagesToBindSynchronously = new IntSet();
2752
2753 clearPendingBinds();
2754 ViewOnDrawExecutor executor = new ViewOnDrawExecutor(pendingTasks);
2755 mPendingExecutor = executor;
2756 if (!isInState(ALL_APPS)) {
2757 mAppsView.getAppsStore().enableDeferUpdates(AllAppsStore.DEFER_UPDATES_NEXT_DRAW);
2758 pendingTasks.add(() -> mAppsView.getAppsStore().disableDeferUpdates(
2759 AllAppsStore.DEFER_UPDATES_NEXT_DRAW));
2760 }
2761
Sunny Goyal7b8d63f2022-04-14 16:37:32 -07002762 if (mOnInitialBindListener != null) {
2763 getRootView().getViewTreeObserver().removeOnPreDrawListener(mOnInitialBindListener);
2764 mOnInitialBindListener = null;
Sunny Goyalb5b9ad62016-04-02 11:23:39 -07002765 }
Sunny Goyal7b8d63f2022-04-14 16:37:32 -07002766
2767 executor.onLoadAnimationCompleted();
Sunny Goyal4a48a982021-06-17 15:15:46 -07002768 executor.attachTo(this);
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -07002769 if (Utilities.ATLEAST_S) {
2770 Trace.endAsyncSection(DISPLAY_WORKSPACE_TRACE_METHOD_NAME,
2771 DISPLAY_WORKSPACE_TRACE_COOKIE);
2772 }
Sunny Goyalb5b9ad62016-04-02 11:23:39 -07002773 }
2774
Joe Onorato9c1289c2009-08-17 11:03:03 -04002775 /**
2776 * Callback saying that there aren't any more items to bind.
2777 *
2778 * Implementation of the method from LauncherModel.Callbacks.
2779 */
Andras Kloczl55edfe52021-05-14 12:21:30 +02002780 public void finishBindingItems(IntSet pagesBoundFirst) {
Winson Chung5cc62c72019-10-16 11:32:41 -07002781 Object traceToken = TraceHelper.INSTANCE.beginSection("finishBindingItems");
Schneider Victor-tulias6b94a962023-02-22 12:08:21 -08002782 if (TestProtocol.sDebugTracing) {
2783 Log.d(TestProtocol.FLAKY_BINDING, "running: finishBindingItems");
2784 }
Adam Cohen1462de32012-07-24 22:34:36 -07002785 mWorkspace.restoreInstanceStateForRemainingPages();
Joe Onorato9c1289c2009-08-17 11:03:03 -04002786
Anjali Koppalff7ceff2014-05-01 18:26:37 -07002787 setWorkspaceLoading(false);
Adam Cohendb364c32014-05-20 14:23:40 -07002788
Sunny Goyal2100c782016-08-22 16:00:03 -07002789 if (mPendingActivityResult != null) {
2790 handleActivityResult(mPendingActivityResult.requestCode,
2791 mPendingActivityResult.resultCode, mPendingActivityResult.data);
2792 mPendingActivityResult = null;
Adam Cohendb364c32014-05-20 14:23:40 -07002793 }
2794
Andras Kloczl55edfe52021-05-14 12:21:30 +02002795 int currentPage = pagesBoundFirst != null && !pagesBoundFirst.isEmpty()
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002796 ? mWorkspace.getPageIndexForScreenId(pagesBoundFirst.getArray().get(0))
2797 : PagedView.INVALID_PAGE;
Tonyf80e8932018-12-21 11:58:04 -08002798 // When undoing the removal of the last item on a page, return to that page.
Tony Wickham03f27012019-04-25 14:22:54 -07002799 // Since we are just resetting the current page without user interaction,
2800 // override the previous page so we don't log the page switch.
Andras Kloczl55edfe52021-05-14 12:21:30 +02002801 mWorkspace.setCurrentPage(currentPage, currentPage /* overridePrevPage */);
2802 mPagesToBindSynchronously = new IntSet();
Tony Wickham6a71a5b2018-08-21 11:40:23 -07002803
Sunny Goyalac6f69f2019-08-16 11:59:55 -07002804 // Cache one page worth of icons
2805 getViewCache().setCacheSize(R.layout.folder_application,
2806 mDeviceProfile.inv.numFolderColumns * mDeviceProfile.inv.numFolderRows);
2807 getViewCache().setCacheSize(R.layout.folder_page, 2);
2808
Winson Chung5cc62c72019-10-16 11:32:41 -07002809 TraceHelper.INSTANCE.endSection(traceToken);
Sebastian Francofa37a0a2022-05-18 10:14:01 -07002810
2811 mWorkspace.removeExtraEmptyScreen(true);
Winson Chungf0c6ae02012-03-21 16:10:31 -07002812 }
2813
Schneider Victor-tulias68fb4162021-09-16 13:24:01 -07002814 private boolean canAnimatePageChange() {
Sunny Goyal9b180102020-03-11 10:02:29 -07002815 if (mDragController.isDragging()) {
2816 return false;
2817 } else {
Riddle Hsu979da642020-09-22 21:52:40 +08002818 return (SystemClock.uptimeMillis() - mLastTouchUpTime)
Sunny Goyal9b180102020-03-11 10:02:29 -07002819 > (NEW_APPS_ANIMATION_INACTIVE_TIMEOUT_SECONDS * 1000);
2820 }
Winson Chunga2413752012-04-03 14:22:34 -07002821 }
2822
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002823 /**
2824 * Similar to {@link #getFirstMatch} but optimized to finding a suitable view for the app close
2825 * animation.
2826 *
2827 * @param preferredItemId The id of the preferred item to match to if it exists.
2828 * @param packageName The package name of the app to match.
2829 * @param user The user of the app to match.
Jon Mirandab42e1242022-03-08 16:37:35 -08002830 * @param supportsAllAppsState If true and we are in All Apps state, looks for view in All Apps.
2831 * Else we only looks on the workspace.
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002832 */
Jon Mirandaf58db152022-06-02 16:06:37 -07002833 public @Nullable View getFirstMatchForAppClose(int preferredItemId, String packageName,
2834 UserHandle user, boolean supportsAllAppsState) {
Sunny Goyal32084d42022-05-02 10:00:07 -07002835 final Predicate<ItemInfo> preferredItem = info ->
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002836 info != null && info.id == preferredItemId;
Sunny Goyal32084d42022-05-02 10:00:07 -07002837 final Predicate<ItemInfo> packageAndUserAndApp = info ->
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002838 info != null
2839 && info.itemType == ITEM_TYPE_APPLICATION
2840 && info.user.equals(user)
2841 && info.getTargetComponent() != null
2842 && TextUtils.equals(info.getTargetComponent().getPackageName(),
2843 packageName);
2844
Jon Mirandab42e1242022-03-08 16:37:35 -08002845 if (supportsAllAppsState && isInState(LauncherState.ALL_APPS)) {
Jon Mirandaf58db152022-06-02 16:06:37 -07002846 AllAppsRecyclerView activeRecyclerView = mAppsView.getActiveRecyclerView();
2847 View v = getFirstMatch(Collections.singletonList(activeRecyclerView),
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002848 preferredItem, packageAndUserAndApp);
Jon Mirandaf58db152022-06-02 16:06:37 -07002849
Sunny Goyalf34811d2022-10-21 20:42:34 +00002850 if (v != null && activeRecyclerView.computeVerticalScrollOffset() > 0) {
Jon Mirandaf58db152022-06-02 16:06:37 -07002851 RectF locationBounds = new RectF();
2852 FloatingIconView.getLocationBoundsForView(this, v, false, locationBounds,
2853 new Rect());
2854 if (locationBounds.top < mAppsView.getHeaderBottom()) {
2855 // Icon is covered by scrim, return null to play fallback animation.
2856 return null;
2857 }
2858 }
2859
2860 return v;
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002861 }
Federico Baron8bf1bca2022-09-27 16:19:11 -07002862
2863 // Look for the item inside the folder at the current page
2864 Folder folder = Folder.getOpen(this);
2865 if (folder != null) {
2866 View v = getFirstMatch(Collections.singletonList(
2867 folder.getContent().getCurrentCellLayout().getShortcutsAndWidgets()),
2868 preferredItem,
2869 packageAndUserAndApp);
2870 if (v == null) {
2871 folder.close(isStarted() && !isForceInvisible());
2872 } else {
2873 return v;
2874 }
2875 }
2876
2877 List<ViewGroup> containers = new ArrayList<>(mWorkspace.getPanelCount() + 1);
2878 containers.add(mWorkspace.getHotseat().getShortcutsAndWidgets());
2879 mWorkspace.forEachVisiblePage(page
2880 -> containers.add(((CellLayout) page).getShortcutsAndWidgets()));
2881
2882 // Order: Preferred item by itself or in folder, then by matching package/user
2883 return getFirstMatch(containers, preferredItem, forFolderMatch(preferredItem),
2884 packageAndUserAndApp, forFolderMatch(packageAndUserAndApp));
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002885 }
2886
2887 /**
2888 * Finds the first view matching the ordered operators across the given viewgroups in order.
2889 * @param containers List of ViewGroups to scan, in order of preference.
2890 * @param operators List of operators, in order starting from best matching operator.
2891 */
Jon Mirandaf26bdcb2022-06-09 16:09:30 -07002892 @Nullable
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002893 private static View getFirstMatch(Iterable<ViewGroup> containers,
Sunny Goyal32084d42022-05-02 10:00:07 -07002894 final Predicate<ItemInfo>... operators) {
2895 for (Predicate<ItemInfo> operator : operators) {
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002896 for (ViewGroup container : containers) {
2897 View match = mapOverViewGroup(container, operator);
2898 if (match != null) {
2899 return match;
2900 }
2901 }
2902 }
2903 return null;
2904 }
2905
2906 /**
2907 * Returns the first view matching the operator in the given ViewGroups, or null if none.
2908 * Forward iteration matters.
2909 */
Jon Mirandaf26bdcb2022-06-09 16:09:30 -07002910 @Nullable
Sunny Goyal32084d42022-05-02 10:00:07 -07002911 private static View mapOverViewGroup(ViewGroup container, Predicate<ItemInfo> op) {
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002912 final int itemCount = container.getChildCount();
2913 for (int itemIdx = 0; itemIdx < itemCount; itemIdx++) {
2914 View item = container.getChildAt(itemIdx);
Sunny Goyal32084d42022-05-02 10:00:07 -07002915 if (op.test((ItemInfo) item.getTag())) {
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002916 return item;
2917 }
2918 }
2919 return null;
2920 }
2921
Winson Chungc9168342013-06-26 14:54:55 -07002922 private ValueAnimator createNewAppBounceAnimation(View v, int i) {
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002923 ValueAnimator bounceAnim = new PropertyListBuilder().alpha(1).scale(1).build(v)
Sunny Goyal60e68c92020-08-12 13:59:27 -07002924 .setDuration(ItemInstallQueue.NEW_SHORTCUT_BOUNCE_DURATION);
2925 bounceAnim.setStartDelay(i * ItemInstallQueue.NEW_SHORTCUT_STAGGER_DELAY);
Sunny Goyal5a1f53b2015-05-27 10:24:24 -07002926 bounceAnim.setInterpolator(new OvershootInterpolator(BOUNCE_ANIMATION_TENSION));
Winson Chungc9168342013-06-26 14:54:55 -07002927 return bounceAnim;
2928 }
2929
Pinyao Tingc9074272019-11-11 11:51:44 -08002930 private void announceForAccessibility(@StringRes int stringResId) {
2931 getDragLayer().announceForAccessibility(getString(stringResId));
2932 }
2933
Amith Yamasani6d7fe502010-11-16 09:05:07 -08002934 /**
Josh Tsuji231c9222022-01-11 20:43:59 -05002935 * Informs us that the overlay (-1 screen, typically), has either become visible or invisible.
2936 */
Sunny Goyal82379182022-11-02 18:58:49 -07002937 public void onOverlayVisibilityChanged(boolean visible) {
2938 getStatsLogManager().logger()
2939 .withSrcState(LAUNCHER_STATE_HOME)
2940 .withDstState(LAUNCHER_STATE_HOME)
2941 .withContainerInfo(LauncherAtom.ContainerInfo.newBuilder()
2942 .setWorkspace(WorkspaceContainer.newBuilder()
2943 .setPageIndex(visible ? 0 : -1))
2944 .build())
2945 .log(visible ? LAUNCHER_SWIPELEFT : LAUNCHER_SWIPERIGHT);
2946 }
Josh Tsuji231c9222022-01-11 20:43:59 -05002947
2948 /**
2949 * Informs us that the page transition has ended, so that we can react to the newly selected
2950 * page if we want to.
2951 */
2952 public void onPageEndTransition() {}
2953
2954 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04002955 * Add the icons for all apps.
2956 *
2957 * Implementation of the method from LauncherModel.Callbacks.
2958 */
Sunny Goyal28daf4a2020-06-08 17:06:09 -07002959 @Override
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -07002960 @TargetApi(Build.VERSION_CODES.S)
Sunny Goyal28daf4a2020-06-08 17:06:09 -07002961 public void bindAllApplications(AppInfo[] apps, int flags) {
2962 mAppsView.getAppsStore().setApps(apps, flags);
Sunny Goyal1818fb72020-11-09 14:32:48 -08002963 PopupContainerWithArrow.dismissInvalidPopup(this);
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -07002964 if (Utilities.ATLEAST_S) {
2965 Trace.endAsyncSection(DISPLAY_ALL_APPS_TRACE_METHOD_NAME,
2966 DISPLAY_ALL_APPS_TRACE_COOKIE);
2967 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04002968 }
2969
2970 /**
Zak Cohen658c67a2018-10-19 14:21:05 -07002971 * Copies LauncherModel's map of activities to shortcut counts to Launcher's. This is necessary
Tony Wickhambfbf7f92016-05-19 11:19:39 -07002972 * because LauncherModel's map is updated in the background, while Launcher runs on the UI.
2973 */
2974 @Override
Zak Cohen658c67a2018-10-19 14:21:05 -07002975 public void bindDeepShortcutMap(HashMap<ComponentKey, Integer> deepShortcutMapCopy) {
Tony Wickham010d2552017-01-20 08:15:28 -08002976 mPopupDataProvider.setDeepShortcutMap(deepShortcutMapCopy);
Tony Wickham1bce7fd2016-04-28 17:39:03 -07002977 }
2978
Sunny Goyal4390ace2014-10-13 11:33:11 -07002979 @Override
Schneider Victor-tulias6a5f4312021-01-12 19:30:02 +00002980 public void bindIncrementalDownloadProgressUpdated(AppInfo app) {
2981 mAppsView.getAppsStore().updateProgressBar(app);
Mario Bertschler08ffaae2017-03-20 11:30:27 -07002982 }
2983
2984 @Override
Sunny Goyal29947f02017-12-18 13:49:44 -08002985 public void bindWidgetsRestored(ArrayList<LauncherAppWidgetInfo> widgets) {
Sunny Goyal4390ace2014-10-13 11:33:11 -07002986 mWorkspace.widgetsRestored(widgets);
2987 }
2988
Joe Onorato9c1289c2009-08-17 11:03:03 -04002989 /**
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07002990 * Some shortcuts were updated in the background.
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07002991 * Implementation of the method from LauncherModel.Callbacks.
Sunny Goyald3b87ef2016-07-28 12:11:54 -07002992 *
2993 * @param updated list of shortcuts which have changed.
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07002994 */
Sunny Goyal4390ace2014-10-13 11:33:11 -07002995 @Override
Sunny Goyal28f50752020-07-21 14:15:13 -07002996 public void bindWorkspaceItemsChanged(List<WorkspaceItemInfo> updated) {
Sunny Goyal4390ace2014-10-13 11:33:11 -07002997 if (!updated.isEmpty()) {
Sunny Goyal711c5962021-06-23 12:36:18 -07002998 mWorkspace.updateWorkspaceItems(updated, this);
Sunny Goyal1818fb72020-11-09 14:32:48 -08002999 PopupContainerWithArrow.dismissInvalidPopup(this);
Sunny Goyal4390ace2014-10-13 11:33:11 -07003000 }
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07003001 }
3002
3003 /**
Chris Wrenaeff7ea2014-02-14 16:59:24 -05003004 * Update the state of a package, typically related to install state.
3005 *
3006 * Implementation of the method from LauncherModel.Callbacks.
3007 */
Sunny Goyale755d462014-07-22 13:48:29 -07003008 @Override
Sunny Goyal29947f02017-12-18 13:49:44 -08003009 public void bindRestoreItemsChange(HashSet<ItemInfo> updates) {
Sunny Goyal711c5962021-06-23 12:36:18 -07003010 mWorkspace.updateRestoreItems(updates, this);
Sunny Goyala22666f2014-09-18 13:25:15 -07003011 }
3012
3013 /**
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07003014 * A package was uninstalled/updated. We take both the super set of packageNames
Winson Chung83892cc2013-05-01 16:53:33 -07003015 * in addition to specific applications to remove, the reason being that
3016 * this can be called when a package is updated as well. In that scenario,
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07003017 * we only remove specific components from the workspace and hotseat, where as
Winson Chung83892cc2013-05-01 16:53:33 -07003018 * package-removal should clear all items by package name.
Joe Onorato9c1289c2009-08-17 11:03:03 -04003019 */
Sunny Goyal1a745e82014-10-02 15:58:31 -07003020 @Override
Sunny Goyal32084d42022-05-02 10:00:07 -07003021 public void bindWorkspaceComponentsRemoved(Predicate<ItemInfo> matcher) {
Sunny Goyal6e13dd32017-08-17 03:01:19 -07003022 mWorkspace.removeItemsByMatcher(matcher);
3023 mDragController.onAppsRemoved(matcher);
Sunny Goyal1818fb72020-11-09 14:32:48 -08003024 PopupContainerWithArrow.dismissInvalidPopup(this);
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07003025 }
Sunny Goyal4390ace2014-10-13 11:33:11 -07003026
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07003027 @Override
Steven Ng2f5648a2021-02-08 17:18:25 +00003028 public void bindAllWidgets(final List<WidgetsListBaseEntry> allWidgets) {
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07003029 mPopupDataProvider.setAllWidgets(allWidgets);
Tony Wickham26b17462017-03-20 17:12:24 -07003030 }
3031
kholoud mohamedc76b2032021-12-20 16:47:38 +00003032 @Override
3033 public void bindStringCache(StringCache cache) {
3034 mStringCache = cache;
3035 }
3036
3037 @Override
3038 public StringCache getStringCache() {
3039 return mStringCache;
3040 }
3041
Tony Wickham86222d22017-03-29 15:30:43 -07003042 /**
3043 * @param packageUser if null, refreshes all widgets and shortcuts, otherwise only
3044 * refreshes the widgets and shortcuts associated with the given package/user
3045 */
3046 public void refreshAndBindWidgetsForPackageUser(@Nullable PackageUserKey packageUser) {
Sunny Goyalc6e97692017-06-02 13:46:55 -07003047 mModel.refreshAndBindWidgetsAndShortcuts(packageUser);
Sunny Goyal2e1efb42016-03-03 16:58:55 -08003048 }
3049
Winson Chung80baf5a2010-08-09 16:03:15 -07003050 /**
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08003051 * $ adb shell dumpsys activity com.android.launcher3.Launcher [--all]
Joe Onoratobe386092009-11-17 17:32:16 -08003052 */
Adam Cohen16d7ffc2011-10-05 17:49:14 -07003053 @Override
3054 public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) {
3055 super.dump(prefix, fd, writer, args);
Sunny Goyala1365452015-10-01 15:46:24 -07003056
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08003057 if (args.length > 0 && TextUtils.equals(args[0], "--all")) {
3058 writer.println(prefix + "Workspace Items");
Sunny Goyal7ce471b2017-08-02 03:37:39 -07003059 for (int i = 0; i < mWorkspace.getPageCount(); i++) {
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08003060 writer.println(prefix + " Homescreen " + i);
3061
3062 ViewGroup layout = ((CellLayout) mWorkspace.getPageAt(i)).getShortcutsAndWidgets();
3063 for (int j = 0; j < layout.getChildCount(); j++) {
3064 Object tag = layout.getChildAt(j).getTag();
3065 if (tag != null) {
3066 writer.println(prefix + " " + tag.toString());
3067 }
3068 }
3069 }
3070
3071 writer.println(prefix + " Hotseat");
Sunny Goyal876e4622018-11-02 13:50:40 -07003072 ViewGroup layout = mHotseat.getShortcutsAndWidgets();
Sunny Goyala1365452015-10-01 15:46:24 -07003073 for (int j = 0; j < layout.getChildCount(); j++) {
3074 Object tag = layout.getChildAt(j).getTag();
3075 if (tag != null) {
3076 writer.println(prefix + " " + tag.toString());
3077 }
Adam Cohen4caf2982013-08-20 18:54:31 -07003078 }
Sunny Goyala1365452015-10-01 15:46:24 -07003079 }
3080
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08003081 writer.println(prefix + "Misc:");
Winson Chungef528762019-09-06 12:05:52 -07003082 dumpMisc(prefix + "\t", writer);
3083 writer.println(prefix + "\tmWorkspaceLoading=" + mWorkspaceLoading);
3084 writer.println(prefix + "\tmPendingRequestArgs=" + mPendingRequestArgs
3085 + " mPendingActivityResult=" + mPendingActivityResult);
3086 writer.println(prefix + "\tmRotationHelper: " + mRotationHelper);
Sihua Ma0593a0d2022-10-03 16:01:48 -07003087 writer.println(prefix + "\tmAppWidgetHolder.isListening: "
3088 + mAppWidgetHolder.isListening());
Winson Chungef528762019-09-06 12:05:52 -07003089
Tony Wickham646e4482020-04-06 17:25:53 -07003090 // Extra logging for general debugging
Hyunyoung Songa310a802019-04-25 13:57:16 -07003091 mDragLayer.dump(prefix, writer);
3092 mStateManager.dump(prefix, writer);
Tony Wickham646e4482020-04-06 17:25:53 -07003093 mPopupDataProvider.dump(prefix, writer);
Pat Manning5f74bfd2022-07-20 12:08:54 +01003094 mDeviceProfile.dump(this, prefix, writer);
Sunny Goyal2bba1902018-02-27 12:20:50 -08003095
3096 try {
3097 FileLog.flushAll(writer);
3098 } catch (Exception e) {
3099 // Ignore
3100 }
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08003101
3102 mModel.dumpState(prefix, fd, writer, args);
Sunny Goyala1365452015-10-01 15:46:24 -07003103
Adam Cohen9211d422014-10-07 18:14:53 -07003104 if (mLauncherCallbacks != null) {
3105 mLauncherCallbacks.dump(prefix, fd, writer, args);
3106 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -07003107 mOverlayManager.dump(prefix, writer);
Adam Cohen16d7ffc2011-10-05 17:49:14 -07003108 }
Adam Cohen487f7dd2012-06-28 18:12:10 -07003109
Sunny Goyal66b24572016-09-21 15:57:55 -07003110 @Override
Sunny Goyal66b24572016-09-21 15:57:55 -07003111 public void onProvideKeyboardShortcuts(
3112 List<KeyboardShortcutGroup> data, Menu menu, int deviceId) {
3113
3114 ArrayList<KeyboardShortcutInfo> shortcutInfos = new ArrayList<>();
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07003115 if (isInState(NORMAL)) {
Sunny Goyal66b24572016-09-21 15:57:55 -07003116 shortcutInfos.add(new KeyboardShortcutInfo(getString(R.string.all_apps_button_label),
3117 KeyEvent.KEYCODE_A, KeyEvent.META_CTRL_ON));
Vadim Tryshev74c261c2018-06-12 13:44:43 -07003118 shortcutInfos.add(new KeyboardShortcutInfo(getString(R.string.widget_button_text),
3119 KeyEvent.KEYCODE_W, KeyEvent.META_CTRL_ON));
Sunny Goyal66b24572016-09-21 15:57:55 -07003120 }
Sunny Goyal384b5782021-02-09 22:50:02 -08003121 getSupportedActions(this, getCurrentFocus()).forEach(la ->
Vadim Tryshev3455f8d2018-05-11 20:02:20 -07003122 shortcutInfos.add(new KeyboardShortcutInfo(
Sunny Goyal384b5782021-02-09 22:50:02 -08003123 la.accessibilityAction.getLabel(), la.keyCode, KeyEvent.META_CTRL_ON)));
Sunny Goyal66b24572016-09-21 15:57:55 -07003124 if (!shortcutInfos.isEmpty()) {
3125 data.add(new KeyboardShortcutGroup(getString(R.string.home_screen), shortcutInfos));
3126 }
3127
3128 super.onProvideKeyboardShortcuts(data, menu, deviceId);
3129 }
3130
3131 @Override
3132 public boolean onKeyShortcut(int keyCode, KeyEvent event) {
3133 if (event.hasModifiers(KeyEvent.META_CTRL_ON)) {
3134 switch (keyCode) {
3135 case KeyEvent.KEYCODE_A:
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07003136 if (isInState(NORMAL)) {
3137 getStateManager().goToState(ALL_APPS);
Sunny Goyal66b24572016-09-21 15:57:55 -07003138 return true;
3139 }
3140 break;
Vadim Tryshev74c261c2018-06-12 13:44:43 -07003141 case KeyEvent.KEYCODE_W:
3142 if (isInState(NORMAL)) {
3143 OptionsPopupView.openWidgets(this);
3144 return true;
3145 }
3146 break;
Sunny Goyal384b5782021-02-09 22:50:02 -08003147 default:
3148 for (LauncherAction la : getSupportedActions(this, getCurrentFocus())) {
3149 if (la.keyCode == keyCode) {
3150 return la.invokeFromKeyboard(getCurrentFocus());
3151 }
3152 }
Sunny Goyal66b24572016-09-21 15:57:55 -07003153 }
3154 }
3155 return super.onKeyShortcut(keyCode, event);
3156 }
3157
Vadim Tryshev646a0dd2018-02-05 16:27:50 -08003158 @Override
3159 public boolean onKeyUp(int keyCode, KeyEvent event) {
3160 if (keyCode == KeyEvent.KEYCODE_MENU) {
3161 // KEYCODE_MENU is sent by some tests, for example
3162 // LauncherJankTests#testWidgetsContainerFling. Don't just remove its handling.
3163 if (!mDragController.isDragging() && !mWorkspace.isSwitchingState() &&
3164 isInState(NORMAL)) {
3165 // Close any open floating views.
Andy Wickham65ced1b2020-03-07 02:14:19 +00003166 closeOpenViews();
Vadim Tryshev646a0dd2018-02-05 16:27:50 -08003167
3168 // Setting the touch point to (-1, -1) will show the options popup in the center of
3169 // the screen.
Brian Isganitisfdd044e2023-03-02 19:45:23 +00003170 if (Utilities.isRunningInTestHarness()) {
vadimtbc5d7e62019-12-09 13:53:05 -08003171 Log.d(TestProtocol.PERMANENT_DIAG_TAG, "Opening options popup on key up");
3172 }
Sunny Goyal831212e2021-05-14 14:24:09 -07003173 showDefaultOptions(-1, -1);
Vadim Tryshev646a0dd2018-02-05 16:27:50 -08003174 }
3175 return true;
3176 }
3177 return super.onKeyUp(keyCode, event);
3178 }
3179
Sunny Goyal831212e2021-05-14 14:24:09 -07003180 /**
3181 * Shows the default options popup
3182 */
3183 public void showDefaultOptions(float x, float y) {
Brian Isganitisa85ae692021-09-23 19:56:24 -04003184 OptionsPopupView.show(this, getPopupTarget(x, y), OptionsPopupView.getOptions(this),
3185 false);
3186 }
3187
3188 /**
3189 * Returns target rectangle for anchoring a popup menu.
3190 */
3191 protected RectF getPopupTarget(float x, float y) {
Sunny Goyal831212e2021-05-14 14:24:09 -07003192 float halfSize = getResources().getDimension(R.dimen.options_menu_thumb_size) / 2;
3193 if (x < 0 || y < 0) {
3194 x = mDragLayer.getWidth() / 2;
3195 y = mDragLayer.getHeight() / 2;
3196 }
Brian Isganitisa85ae692021-09-23 19:56:24 -04003197 return new RectF(x - halfSize, y - halfSize, x + halfSize, y + halfSize);
3198 }
3199
3200 @Override
Charlie Anderson8ad91442023-01-09 13:55:59 -05003201 public boolean canUseMultipleShadesForPopup() {
Brian Isganitisa85ae692021-09-23 19:56:24 -04003202 return getTopOpenViewWithType(this, TYPE_FOLDER) == null
3203 && getStateManager().getState() != LauncherState.ALL_APPS;
Sunny Goyal831212e2021-05-14 14:24:09 -07003204 }
3205
Sunny Goyalb5181c82021-03-10 07:39:12 +00003206 @Override
3207 protected void collectStateHandlers(List<StateHandler> out) {
3208 out.add(getAllAppsController());
3209 out.add(getWorkspace());
Andrew Sappersteinabef55a2016-06-19 12:49:00 -07003210 }
3211
Sunny Goyal210e1742019-10-17 12:05:38 -07003212 public TouchController[] createTouchControllers() {
3213 return new TouchController[] {getDragController(), new AllAppsSwipeController(this)};
3214 }
3215
Sunny Goyal210e1742019-10-17 12:05:38 -07003216 public void useFadeOutAnimationForLauncherStart(CancellationSignal signal) { }
3217
Sunny Goyal1eb11242022-09-09 17:14:45 -07003218 public void onDragLayerHierarchyChanged() {
3219 updateDisallowBack();
3220 }
3221
3222 private void updateDisallowBack() {
Ats Jenk8121e0d2022-12-01 11:34:43 -08003223 if (DESKTOP_MODE_1_SUPPORTED || DESKTOP_MODE_2_SUPPORTED) {
3224 // Do not disable back in launcher when prototype behavior is enabled
3225 return;
3226 }
Sunny Goyal1eb11242022-09-09 17:14:45 -07003227 LauncherRootView rv = getRootView();
3228 if (rv != null) {
3229 boolean disableBack = getStateManager().getState() == NORMAL
3230 && AbstractFloatingView.getTopOpenView(this) == null;
3231 rv.setDisallowBackGesture(disableBack);
3232 }
3233 }
Sunny Goyal210e1742019-10-17 12:05:38 -07003234
Vinit Nayakf9b585b2019-07-10 14:25:32 -07003235 @Override
3236 public void returnToHomescreen() {
3237 super.returnToHomescreen();
3238 getStateManager().goToState(LauncherState.NORMAL);
3239 }
3240
Andy Wickham65ced1b2020-03-07 02:14:19 +00003241 private void closeOpenViews() {
3242 closeOpenViews(true);
3243 }
3244
3245 protected void closeOpenViews(boolean animate) {
3246 AbstractFloatingView.closeAllOpenViews(this, animate);
3247 }
3248
Sunny Goyal3a1eadd2019-10-23 17:44:27 -07003249 public Stream<SystemShortcut.Factory> getSupportedShortcuts() {
Samuel Fufa5cf3e862020-02-03 20:22:54 -08003250 return Stream.of(APP_INFO, WIDGETS, INSTALL);
Sunny Goyal3a1eadd2019-10-23 17:44:27 -07003251 }
3252
Sunny Goyal384b5782021-02-09 22:50:02 -08003253 protected LauncherAccessibilityDelegate createAccessibilityDelegate() {
3254 return new LauncherAccessibilityDelegate(this);
3255 }
Sunny Goyalf2393f12020-04-01 20:13:12 -07003256
3257 /**
3258 * @see LauncherState#getOverviewScaleAndOffset(Launcher)
3259 */
3260 public float[] getNormalOverviewScaleAndOffset() {
Tony Wickham82d5a062021-05-14 14:37:12 -07003261 return new float[] {NO_SCALE, NO_OFFSET};
Sunny Goyalf2393f12020-04-01 20:13:12 -07003262 }
3263
Sunny Goyal210e1742019-10-17 12:05:38 -07003264 public static Launcher getLauncher(Context context) {
Winson Chung8687bc22020-02-27 23:34:24 -08003265 return fromContext(context);
Sunny Goyal210e1742019-10-17 12:05:38 -07003266 }
3267
Sunny Goyal3dce5f32017-10-05 11:40:05 -07003268 /**
Sunny Goyalab770a12018-11-14 15:17:26 -08003269 * Just a wrapper around the type cast to allow easier tracking of calls.
3270 */
3271 public static <T extends Launcher> T cast(ActivityContext activityContext) {
3272 return (T) activityContext;
3273 }
3274
Sunny Goyalb65d7662021-03-07 15:09:11 -08003275 public boolean supportsAdaptiveIconAnimation(View clickedView) {
3276 return false;
3277 }
3278
Tony Wickham39938cb2021-02-26 09:15:31 -08003279 public DragOptions getDefaultWorkspaceDragOptions() {
3280 return new DragOptions();
3281 }
3282
Schneider Victor-tulias9b6babf2022-03-24 14:47:32 -07003283 /**
3284 * Animates Launcher elements during a transition to the All Apps page.
3285 *
3286 * @param progress Transition progress from 0 to 1; where 0 => home and 1 => all apps.
3287 */
3288 public void onAllAppsTransition(float progress) {
3289 // No-Op
3290 }
3291
3292 /**
3293 * Animates Launcher elements during a transition to the Widgets pages.
3294 *
3295 * @param progress Transition progress from 0 to 1; where 0 => home and 1 => widgets.
3296 */
3297 public void onWidgetsTransition(float progress) {
Alex Chau3d2c0622022-09-01 21:28:14 +01003298 float scale = Utilities.mapToRange(progress, 0f, 1f, 1f,
3299 mDeviceProfile.bottomSheetWorkspaceScale, EMPHASIZED);
3300 WORKSPACE_WIDGET_SCALE.set(getWorkspace(), scale);
3301 HOTSEAT_WIDGET_SCALE.set(getHotseat(), scale);
Schneider Victor-tulias9b6babf2022-03-24 14:47:32 -07003302 }
3303
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08003304 private static class NonConfigInstance {
3305 public Configuration config;
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08003306 }
thiruramc96873c2021-02-11 15:13:47 -08003307
3308 @Override
3309 public StatsLogManager getStatsLogManager() {
3310 return super.getStatsLogManager().withDefaultInstanceId(mAllAppsSessionLogId);
3311 }
Brian Isganitis149dbcb2021-11-08 18:12:38 -05003312
3313 /**
3314 * Returns the current popup for testing, if any.
3315 */
3316 @VisibleForTesting
3317 @Nullable
3318 public ArrowPopup<?> getOptionsPopup() {
3319 return findViewById(R.id.popup_container);
3320 }
Schneider Victor-tulias789a6a92022-03-04 12:06:09 -08003321
3322 /** Pauses view updates that should not be run during the app launch animation. */
3323 public void pauseExpensiveViewUpdates() {
3324 // Pause page indicator animations as they lead to layer trashing.
Shikha Malhotrae957b602022-04-11 07:57:18 +00003325 getWorkspace().getPageIndicator().pauseAnimations();
Jon Miranda46ecc0c2022-06-02 11:34:15 -07003326
3327 getWorkspace().mapOverItems((info, view) -> {
3328 if (view instanceof LauncherAppWidgetHostView) {
3329 ((LauncherAppWidgetHostView) view).beginDeferringUpdates();
3330 }
3331 return false; // Return false to continue iterating through all the items.
3332 });
Schneider Victor-tulias789a6a92022-03-04 12:06:09 -08003333 }
3334
3335 /** Resumes view updates at the end of the app launch animation. */
3336 public void resumeExpensiveViewUpdates() {
Shikha Malhotrae957b602022-04-11 07:57:18 +00003337 getWorkspace().getPageIndicator().skipAnimationsToEnd();
Shikha Malhotra0f2e1b62022-03-27 21:02:21 +00003338
Jon Miranda46ecc0c2022-06-02 11:34:15 -07003339 getWorkspace().mapOverItems((info, view) -> {
3340 if (view instanceof LauncherAppWidgetHostView) {
3341 ((LauncherAppWidgetHostView) view).endDeferringUpdates();
3342 }
3343 return false; // Return false to continue iterating through all the items.
3344 });
3345 }
Ats Jenkca009e42023-01-06 09:52:40 -08003346
3347 /**
3348 * Returns {@code true} if there are visible tasks with windowing mode set to
3349 * {@link android.app.WindowConfiguration#WINDOWING_MODE_FREEFORM}
3350 */
3351 public boolean areFreeformTasksVisible() {
3352 return false; // Base launcher does not track freeform tasks
3353 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003354}