blob: 2b38e8a4ede6b401e1521073a43ce7bcc91afde2 [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
Kateryna Ivanova71203732023-05-24 15:09:00 +000024import static com.android.app.animation.Interpolators.EMPHASIZED;
Pinyao Tinga74b63a2019-07-17 23:26:06 -070025import static com.android.launcher3.AbstractFloatingView.TYPE_ALL;
Brian Isganitisa85ae692021-09-23 19:56:24 -040026import static com.android.launcher3.AbstractFloatingView.TYPE_FOLDER;
Sunny Goyal30ac97d2020-06-24 23:47:46 -070027import static com.android.launcher3.AbstractFloatingView.TYPE_ICON_SURFACE;
Pinyao Tinga74b63a2019-07-17 23:26:06 -070028import static com.android.launcher3.AbstractFloatingView.TYPE_REBIND_SAFE;
Tony Wickham6a71a5b2018-08-21 11:40:23 -070029import static com.android.launcher3.AbstractFloatingView.TYPE_SNACKBAR;
Brian Isganitisa85ae692021-09-23 19:56:24 -040030import static com.android.launcher3.AbstractFloatingView.getTopOpenViewWithType;
fbarone58aaf12023-09-25 11:34:56 -070031import static com.android.launcher3.BuildConfig.APPLICATION_ID;
fbaronc0e687b2023-10-04 12:11:20 -070032import static com.android.launcher3.BuildConfig.QSB_ON_FIRST_SCREEN;
Alex Chau0c4e11b2022-07-08 18:41:36 +010033import static com.android.launcher3.LauncherAnimUtils.HOTSEAT_SCALE_PROPERTY_FACTORY;
34import static com.android.launcher3.LauncherAnimUtils.SCALE_INDEX_WIDGET_TRANSITION;
Sunny Goyal4c7f2152017-10-17 17:17:16 -070035import static com.android.launcher3.LauncherAnimUtils.SPRING_LOADED_EXIT_DELAY;
Alex Chau0c4e11b2022-07-08 18:41:36 +010036import static com.android.launcher3.LauncherAnimUtils.WORKSPACE_SCALE_PROPERTY_FACTORY;
Sunny Goyal669b71f2023-01-27 14:37:07 -080037import static com.android.launcher3.LauncherSettings.Favorites.CONTAINER_DESKTOP;
Jon Mirandac4a99bf2021-11-04 16:53:45 -070038import static com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_APPLICATION;
Sunny Goyal3e3f44c2017-10-23 17:14:52 -070039import static com.android.launcher3.LauncherState.ALL_APPS;
Charlie Anderson438d4052023-04-25 14:38:57 -040040import static com.android.launcher3.LauncherState.EDIT_MODE;
Sunny Goyal8f965462020-04-23 19:00:36 -070041import static com.android.launcher3.LauncherState.FLAG_MULTI_PAGE;
42import static com.android.launcher3.LauncherState.FLAG_NON_INTERACTIVE;
Sunny Goyal3e3f44c2017-10-23 17:14:52 -070043import static com.android.launcher3.LauncherState.NORMAL;
Sunny Goyalf2393f12020-04-01 20:13:12 -070044import static com.android.launcher3.LauncherState.NO_OFFSET;
45import static com.android.launcher3.LauncherState.NO_SCALE;
Sunny Goyal8f965462020-04-23 19:00:36 -070046import static com.android.launcher3.LauncherState.SPRING_LOADED;
Sunny Goyalb1d7de22019-09-06 10:36:54 -070047import static com.android.launcher3.Utilities.postAsyncCallback;
fbarone58aaf12023-09-25 11:34:56 -070048import static com.android.launcher3.WorkspaceLayoutManager.FIRST_SCREEN_ID;
fbaronc0e687b2023-10-04 12:11:20 -070049import static com.android.launcher3.config.FeatureFlags.ENABLE_SMARTSPACE_REMOVAL;
Sebastián Franco1f4d56c2023-08-08 03:29:10 +000050import static com.android.launcher3.config.FeatureFlags.FOLDABLE_SINGLE_PAGE;
Charlie Anderson438d4052023-04-25 14:38:57 -040051import static com.android.launcher3.config.FeatureFlags.MULTI_SELECT_EDIT_MODE;
fbarone58aaf12023-09-25 11:34:56 -070052import static com.android.launcher3.config.FeatureFlags.shouldShowFirstPageWidget;
Thiru Ramasamy5fbac632022-01-28 15:05:36 -080053import static com.android.launcher3.logging.StatsLogManager.EventEnum;
Hyunyoung Song801f81f2020-06-19 02:58:53 -070054import static com.android.launcher3.logging.StatsLogManager.LAUNCHER_STATE_BACKGROUND;
Hyunyoung Song95786e02020-09-15 00:34:10 -070055import static com.android.launcher3.logging.StatsLogManager.LAUNCHER_STATE_HOME;
thiruramc96873c2021-02-11 15:13:47 -080056import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ALLAPPS_ENTRY;
thiruram9f53d612021-02-24 10:54:01 -080057import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ALLAPPS_ENTRY_WITH_DEVICE_SEARCH;
thiruramc96873c2021-02-11 15:13:47 -080058import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ALLAPPS_EXIT;
Hyunyoung Song801f81f2020-06-19 02:58:53 -070059import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ONRESUME;
60import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ONSTOP;
Sunny Goyal82379182022-11-02 18:58:49 -070061import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_SWIPELEFT;
62import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_SWIPERIGHT;
Yogisha Dixit4ff5ee32021-05-04 14:58:34 +010063import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_WIDGET_RECONFIGURED;
Fengjiang Li5a36c172023-04-13 18:18:27 +000064import static com.android.launcher3.logging.StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_ACTIVITY_ON_CREATE;
65import static com.android.launcher3.logging.StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_TOTAL_DURATION;
66import static com.android.launcher3.logging.StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_VIEW_INFLATION;
67import static com.android.launcher3.logging.StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_ASYNC;
68import static com.android.launcher3.logging.StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_SYNC;
69import static com.android.launcher3.logging.StatsLogManager.StatsLatencyLogger.LatencyType.COLD;
70import static com.android.launcher3.logging.StatsLogManager.StatsLatencyLogger.LatencyType.COLD_DEVICE_REBOOTING;
71import static com.android.launcher3.logging.StatsLogManager.StatsLatencyLogger.LatencyType.WARM;
Sunny Goyal60e68c92020-08-12 13:59:27 -070072import static com.android.launcher3.model.ItemInstallQueue.FLAG_ACTIVITY_PAUSED;
73import static com.android.launcher3.model.ItemInstallQueue.FLAG_DRAG_AND_DROP;
fbaron30d9e3f2023-08-03 17:03:59 -070074import static com.android.launcher3.model.data.LauncherAppWidgetInfo.CUSTOM_WIDGET_ID;
Sunny Goyal3a1eadd2019-10-23 17:44:27 -070075import static com.android.launcher3.popup.SystemShortcut.APP_INFO;
Sunny Goyal3a1eadd2019-10-23 17:44:27 -070076import static com.android.launcher3.popup.SystemShortcut.INSTALL;
77import static com.android.launcher3.popup.SystemShortcut.WIDGETS;
Sunny Goyal8f965462020-04-23 19:00:36 -070078import static com.android.launcher3.states.RotationHelper.REQUEST_LOCK;
Sunny Goyalbe8c3402019-05-22 15:17:52 -070079import static com.android.launcher3.states.RotationHelper.REQUEST_NONE;
Jeremy Sim7cf0dd92023-03-24 22:39:45 -070080import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
Jon Mirandac4a99bf2021-11-04 16:53:45 -070081import static com.android.launcher3.util.ItemInfoMatcher.forFolderMatch;
Sunny Goyal326403e2017-10-02 12:45:10 -070082
Gilles Debunnedd6c9922010-10-25 11:23:41 -070083import android.animation.Animator;
Sunny Goyal6001ea22018-05-10 16:31:00 -070084import android.animation.AnimatorListenerAdapter;
Gilles Debunnedd6c9922010-10-25 11:23:41 -070085import android.animation.AnimatorSet;
Gilles Debunnedd6c9922010-10-25 11:23:41 -070086import android.animation.ValueAnimator;
Adam Cohen0b395352014-06-09 22:54:36 +000087import android.annotation.TargetApi;
Tony Wickhame78a70b2021-03-29 16:45:59 -070088import android.app.Notification;
89import android.app.NotificationChannel;
90import android.app.NotificationManager;
91import android.app.PendingIntent;
Adam Cohen0cf2a7c2011-11-08 15:07:01 -080092import android.appwidget.AppWidgetHostView;
Michael Jurkaaf442092010-06-10 17:01:57 -070093import android.appwidget.AppWidgetManager;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080094import android.content.ActivityNotFoundException;
Michael Jurkae326f182011-11-21 14:05:46 -080095import android.content.ComponentCallbacks2;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080096import android.content.Context;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080097import android.content.Intent;
Adam Cohen173f7112015-03-27 15:14:00 -070098import android.content.IntentSender;
Winson Chung82f55532011-08-09 14:14:23 -070099import android.content.SharedPreferences;
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800100import android.content.res.Configuration;
Adam Cohen3f9c9712014-10-31 11:48:25 -0700101import android.database.sqlite.SQLiteDatabase;
Sunny Goyal5cd1b192023-04-06 22:33:11 +0000102import android.graphics.Color;
Tony Wickham1906cc32021-02-11 11:55:24 -0800103import android.graphics.Rect;
Sunny Goyal831212e2021-05-14 14:24:09 -0700104import android.graphics.RectF;
Adam Cohen0f668f32014-09-08 19:54:17 +0200105import android.os.Build;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800106import android.os.Bundle;
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -0700107import android.os.Parcelable;
Winson Chunga2413752012-04-03 14:22:34 -0700108import android.os.StrictMode;
Riddle Hsu979da642020-09-22 21:52:40 +0800109import android.os.SystemClock;
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -0700110import android.os.Trace;
Jon Mirandac4a99bf2021-11-04 16:53:45 -0700111import android.os.UserHandle;
Michael Jurkaa33411c2012-06-14 16:18:21 -0700112import android.text.TextUtils;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800113import android.text.method.TextKeyListener;
Federico Baron7539d762022-09-29 09:47:04 -0700114import android.util.AttributeSet;
Alex Chau0c4e11b2022-07-08 18:41:36 +0100115import android.util.FloatProperty;
Joe Onorato7c312c12009-08-13 21:36:53 -0700116import android.util.Log;
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -0700117import android.util.SparseArray;
Adam Cohen96d30a12013-07-16 18:13:21 -0700118import android.view.KeyEvent;
Sunny Goyal66b24572016-09-21 15:57:55 -0700119import android.view.KeyboardShortcutGroup;
Sunny Goyal9b29ca52017-02-17 10:39:44 -0800120import android.view.LayoutInflater;
Adam Cohen96d30a12013-07-16 18:13:21 -0700121import android.view.Menu;
vadimt9af34a72020-01-21 11:19:13 -0800122import android.view.MotionEvent;
Adam Cohen96d30a12013-07-16 18:13:21 -0700123import android.view.View;
Adam Cohen96d30a12013-07-16 18:13:21 -0700124import android.view.ViewGroup;
Fengjiang Li5a36c172023-04-13 18:18:27 +0000125import android.view.ViewTreeObserver;
Sunny Goyal7b8d63f2022-04-14 16:37:32 -0700126import android.view.ViewTreeObserver.OnPreDrawListener;
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -0700127import android.view.WindowManager.LayoutParams;
Svetoslav Ganov815ba2d2011-01-07 14:55:17 -0800128import android.view.accessibility.AccessibilityEvent;
Sunny Goyal5a1f53b2015-05-27 10:24:24 -0700129import android.view.animation.OvershootInterpolator;
Fengjiang Lib7860bd2023-03-15 10:50:50 -0700130import android.window.BackEvent;
131import android.window.OnBackAnimationCallback;
Sunny Goyala1d1bf32015-06-26 13:24:53 -0700132
Sunny Goyal35e7d382020-05-08 13:37:58 -0700133import androidx.annotation.CallSuper;
Andras Kloczl55edfe52021-05-14 12:21:30 +0200134import androidx.annotation.NonNull;
Sunny Goyal11a50742019-08-07 09:24:26 -0700135import androidx.annotation.Nullable;
Fengjiang Lid0c23592023-04-20 16:42:25 -0700136import androidx.annotation.RequiresApi;
Pinyao Tingc9074272019-11-11 11:51:44 -0800137import androidx.annotation.StringRes;
Anushree Ganjam97434ee2023-05-18 22:03:16 +0000138import androidx.annotation.UiThread;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700139import androidx.annotation.VisibleForTesting;
Sunny Goyal11a50742019-08-07 09:24:26 -0700140
Sunny Goyal651077b2014-06-30 14:15:31 -0700141import com.android.launcher3.DropTarget.DragObject;
Sunny Goyalae502842016-06-17 08:43:56 -0700142import com.android.launcher3.accessibility.LauncherAccessibilityDelegate;
Brian Isganitis1664c9f2022-01-14 23:15:47 -0500143import com.android.launcher3.allapps.ActivityAllAppsContainerView;
Jon Mirandaf58db152022-06-02 16:06:37 -0700144import com.android.launcher3.allapps.AllAppsRecyclerView;
vadimtd4c90e12019-06-04 13:59:43 -0700145import com.android.launcher3.allapps.AllAppsStore;
Hyunyoung Song645764e2016-06-06 14:19:02 -0700146import com.android.launcher3.allapps.AllAppsTransitionController;
Becky Qiu4ed3dfc2022-10-19 16:58:22 -0700147import com.android.launcher3.allapps.BaseSearchConfig;
Sunny Goyal7ede6112017-12-05 15:11:21 -0800148import com.android.launcher3.allapps.DiscoveryBounce;
Holly Sund9d70ea2023-09-05 13:14:22 -0700149import com.android.launcher3.anim.AnimationSuccessListener;
Sunny Goyalf0b6db72018-08-13 16:10:14 -0700150import com.android.launcher3.anim.PropertyListBuilder;
Jeremy Sim94fd07e2023-04-19 20:56:49 -0700151import com.android.launcher3.apppairs.AppPairIcon;
Sunny Goyal669b71f2023-01-27 14:37:07 -0800152import com.android.launcher3.celllayout.CellPosMapper;
153import com.android.launcher3.celllayout.CellPosMapper.CellPos;
Sebastian Franco09589322022-11-02 15:25:58 -0700154import com.android.launcher3.celllayout.CellPosMapper.TwoPanelCellPosMapper;
Sunny Goyal8f965462020-04-23 19:00:36 -0700155import com.android.launcher3.compat.AccessibilityManagerCompat;
Tony Wickhame0c33232016-02-08 11:37:04 -0800156import com.android.launcher3.config.FeatureFlags;
vadimt00d42552018-12-11 17:59:36 -0800157import com.android.launcher3.dot.DotInfo;
Vadim Tryshevfedca432015-08-19 17:55:02 -0700158import com.android.launcher3.dragndrop.DragController;
159import com.android.launcher3.dragndrop.DragLayer;
160import com.android.launcher3.dragndrop.DragView;
Sunny Goyal59969372021-05-06 12:11:44 -0700161import com.android.launcher3.dragndrop.LauncherDragController;
Federico Baron8bf1bca2022-09-27 16:19:11 -0700162import com.android.launcher3.folder.Folder;
Sunny Goyal11a50742019-08-07 09:24:26 -0700163import com.android.launcher3.folder.FolderGridOrganizer;
Sunny Goyal26119432016-02-18 22:09:23 +0000164import com.android.launcher3.folder.FolderIcon;
Sunny Goyalf840f102018-09-21 14:41:05 -0700165import com.android.launcher3.icons.IconCache;
Sunny Goyal3333b0c2016-05-09 20:43:21 -0700166import com.android.launcher3.keyboard.ViewGroupFocusHelper;
Hyunyoung Song801f81f2020-06-19 02:58:53 -0700167import com.android.launcher3.logger.LauncherAtom;
Thiru Ramasamy5fbac632022-01-28 15:05:36 -0800168import com.android.launcher3.logger.LauncherAtom.ContainerInfo;
169import com.android.launcher3.logger.LauncherAtom.WorkspaceContainer;
Sunny Goyala7ce1662016-05-31 15:01:35 -0700170import com.android.launcher3.logging.FileLog;
thiruramc96873c2021-02-11 15:13:47 -0800171import com.android.launcher3.logging.InstanceId;
172import com.android.launcher3.logging.InstanceIdSequence;
Fengjiang Li5a36c172023-04-13 18:18:27 +0000173import com.android.launcher3.logging.StartupLatencyLogger;
Hyunyoung Song801f81f2020-06-19 02:58:53 -0700174import com.android.launcher3.logging.StatsLogManager;
Sunny Goyal87dcde62019-07-17 20:35:56 -0700175import com.android.launcher3.model.BgDataModel.Callbacks;
Sunny Goyal60e68c92020-08-12 13:59:27 -0700176import com.android.launcher3.model.ItemInstallQueue;
Sunny Goyala535ae42017-02-27 10:07:13 -0800177import com.android.launcher3.model.ModelWriter;
kholoud mohamedc76b2032021-12-20 16:47:38 +0000178import com.android.launcher3.model.StringCache;
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -0700179import com.android.launcher3.model.WidgetsModel;
Sunny Goyale396abf2020-04-06 15:11:17 -0700180import com.android.launcher3.model.data.AppInfo;
181import com.android.launcher3.model.data.FolderInfo;
182import com.android.launcher3.model.data.ItemInfo;
183import com.android.launcher3.model.data.LauncherAppWidgetInfo;
Sunny Goyale396abf2020-04-06 15:11:17 -0700184import com.android.launcher3.model.data.WorkspaceItemInfo;
Sunny Goyala535ae42017-02-27 10:07:13 -0800185import com.android.launcher3.notification.NotificationListener;
Federico Baron7539d762022-09-29 09:47:04 -0700186import com.android.launcher3.pageindicators.WorkspacePageIndicator;
Sunny Goyale7b00122019-10-02 16:13:34 -0700187import com.android.launcher3.pm.PinRequestHelper;
Brian Isganitis149dbcb2021-11-08 18:12:38 -0500188import com.android.launcher3.popup.ArrowPopup;
Tony Wickham540913e2017-01-23 11:47:51 -0800189import com.android.launcher3.popup.PopupContainerWithArrow;
Sunny Goyala535ae42017-02-27 10:07:13 -0800190import com.android.launcher3.popup.PopupDataProvider;
Sunny Goyal3a1eadd2019-10-23 17:44:27 -0700191import com.android.launcher3.popup.SystemShortcut;
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700192import com.android.launcher3.qsb.QsbContainerView;
Sunny Goyal35e7d382020-05-08 13:37:58 -0700193import com.android.launcher3.statemanager.StateManager;
194import com.android.launcher3.statemanager.StateManager.StateHandler;
Sunny Goyal35e7d382020-05-08 13:37:58 -0700195import com.android.launcher3.statemanager.StatefulActivity;
Sunny Goyal623eddd2018-03-02 12:24:41 -0800196import com.android.launcher3.states.RotationHelper;
vadimt9af34a72020-01-21 11:19:13 -0800197import com.android.launcher3.testing.TestLogging;
vadimtf6ef8792022-07-26 13:54:31 -0700198import com.android.launcher3.testing.shared.TestProtocol;
Sunny Goyal210e1742019-10-17 12:05:38 -0700199import com.android.launcher3.touch.AllAppsSwipeController;
Brian Isganitisf54c6fa2023-07-11 12:47:08 -0400200import com.android.launcher3.touch.ItemLongClickListener;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700201import com.android.launcher3.uioverrides.plugins.PluginManagerWrapper;
Sunny Goyal2100c782016-08-22 16:00:03 -0700202import com.android.launcher3.util.ActivityResultInfo;
Sunny Goyale84c5b82019-09-26 17:05:31 -0700203import com.android.launcher3.util.ActivityTracker;
Vinit Nayak65460402023-08-11 15:40:07 -0700204import com.android.launcher3.util.BackPressHandler;
Sukesh Ram3f2338a2023-08-28 18:31:54 +0000205import com.android.launcher3.util.CannedAnimationCoordinator;
Winson Chung6b1c73f2015-06-18 11:38:42 -0700206import com.android.launcher3.util.ComponentKey;
Sunny Goyalefb7e842018-10-04 15:11:00 -0700207import com.android.launcher3.util.IntArray;
Andras Kloczl55edfe52021-05-14 12:21:30 +0200208import com.android.launcher3.util.IntSet;
Sebastian Franco4080fdd2023-09-19 14:17:23 -0700209import com.android.launcher3.util.KeyboardShortcutsDelegate;
Fengjiang Li5a36c172023-04-13 18:18:27 +0000210import com.android.launcher3.util.LockedUserState;
Tony Wickham133cd542020-04-08 17:48:41 -0700211import com.android.launcher3.util.OnboardingPrefs;
Tony Wickham010d2552017-01-20 08:15:28 -0800212import com.android.launcher3.util.PackageUserKey;
Sunny Goyal2100c782016-08-22 16:00:03 -0700213import com.android.launcher3.util.PendingRequestArgs;
Anushree Ganjam97434ee2023-05-18 22:03:16 +0000214import com.android.launcher3.util.Preconditions;
Sunny Goyal4a48a982021-06-17 15:15:46 -0700215import com.android.launcher3.util.RunnableList;
Sunny Goyala992ac92023-01-10 17:50:32 -0800216import com.android.launcher3.util.ScreenOnTracker;
217import com.android.launcher3.util.ScreenOnTracker.ScreenOnListener;
Sunny Goyal8392c822017-06-20 10:03:56 -0700218import com.android.launcher3.util.SystemUiController;
Mario Bertschlera6936942017-05-31 14:48:19 -0700219import com.android.launcher3.util.Themes;
Adam Cohen091440a2015-03-18 14:16:05 -0700220import com.android.launcher3.util.Thunk;
Sunny Goyal210e1742019-10-17 12:05:38 -0700221import com.android.launcher3.util.TouchController;
Sunny Goyalfca6bc92017-09-28 16:28:34 -0700222import com.android.launcher3.util.TraceHelper;
Sunny Goyal527c7d32015-08-28 15:19:36 -0700223import com.android.launcher3.util.ViewOnDrawExecutor;
Sunny Goyalab770a12018-11-14 15:17:26 -0800224import com.android.launcher3.views.ActivityContext;
Xiaowen Lei3c0f30a2023-04-12 16:59:45 -0700225import com.android.launcher3.views.ComposeInitializer;
Jon Mirandaf58db152022-06-02 16:06:37 -0700226import com.android.launcher3.views.FloatingIconView;
Sunny Goyal30ac97d2020-06-24 23:47:46 -0700227import com.android.launcher3.views.FloatingSurfaceView;
Sunny Goyal7c7be8c2018-03-07 19:58:07 -0800228import com.android.launcher3.views.OptionsPopupView;
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400229import com.android.launcher3.views.ScrimView;
Sunny Goyal29947f02017-12-18 13:49:44 -0800230import com.android.launcher3.widget.LauncherAppWidgetHostView;
Yogisha Dixit741fae92021-02-22 14:03:44 +0000231import com.android.launcher3.widget.LauncherAppWidgetProviderInfo;
Sihua Ma8bbfcb62022-11-08 16:46:07 -0800232import com.android.launcher3.widget.LauncherWidgetHolder;
Sunny Goyal782f0c92017-01-19 10:27:54 -0800233import com.android.launcher3.widget.PendingAddShortcutInfo;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700234import com.android.launcher3.widget.PendingAddWidgetInfo;
Sunny Goyal29947f02017-12-18 13:49:44 -0800235import com.android.launcher3.widget.PendingAppWidgetHostView;
Sunny Goyal04a324a2017-01-20 21:08:59 -0800236import com.android.launcher3.widget.WidgetAddFlowHandler;
Sunny Goyal337c81f2019-12-10 12:19:13 -0800237import com.android.launcher3.widget.WidgetManagerHelper;
Pinyao Tingc7a6c292019-08-26 14:36:02 -0700238import com.android.launcher3.widget.custom.CustomWidgetManager;
Steven Ng2f5648a2021-02-08 17:18:25 +0000239import com.android.launcher3.widget.model.WidgetsListBaseEntry;
240import com.android.launcher3.widget.picker.WidgetsFullSheet;
Sunny Goyal80a071b2021-12-27 13:30:08 +0530241import com.android.systemui.plugins.LauncherOverlayPlugin;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700242import com.android.systemui.plugins.PluginListener;
243import com.android.systemui.plugins.shared.LauncherExterns;
244import com.android.systemui.plugins.shared.LauncherOverlayManager;
245import com.android.systemui.plugins.shared.LauncherOverlayManager.LauncherOverlay;
Adam Cohen6c5891a2014-07-09 23:53:15 -0700246
Adam Cohen16d7ffc2011-10-05 17:49:14 -0700247import java.io.FileDescriptor;
Adam Cohen16d7ffc2011-10-05 17:49:14 -0700248import java.io.PrintWriter;
Adam Cohenc0dcf592011-06-01 15:30:43 -0700249import java.util.ArrayList;
Winson Chungf0c6ae02012-03-21 16:10:31 -0700250import java.util.Collection;
Jon Mirandac4a99bf2021-11-04 16:53:45 -0700251import java.util.Collections;
Zak Cohen658c67a2018-10-19 14:21:05 -0700252import java.util.HashMap;
Sunny Goyal4390ace2014-10-13 11:33:11 -0700253import java.util.HashSet;
Michael Jurkad7c28052012-04-27 15:43:36 -0700254import java.util.List;
Anushree Ganjam97434ee2023-05-18 22:03:16 +0000255import java.util.Map;
Thiru Ramasamy694407c2022-03-08 12:11:24 -0800256import java.util.Optional;
Sunny Goyalaae6fbb2019-01-31 16:05:58 -0800257import java.util.function.Predicate;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700258import java.util.function.Supplier;
Sunny Goyal3a1eadd2019-10-23 17:44:27 -0700259import java.util.stream.Stream;
Jon Mirandaf5197fc2019-09-04 16:55:41 -0700260
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800261/**
262 * Default launcher application.
263 */
Shikha Malhotra0f2e1b62022-03-27 21:02:21 +0000264public class Launcher extends StatefulActivity<LauncherState>
265 implements LauncherExterns, Callbacks, InvariantDeviceProfile.OnIDPChangeListener,
Sunny Goyal82379182022-11-02 18:58:49 -0700266 PluginListener<LauncherOverlayPlugin> {
Vadim Tryshevfedca432015-08-19 17:55:02 -0700267 public static final String TAG = "Launcher";
Sunny Goyale84c5b82019-09-26 17:05:31 -0700268
269 public static final ActivityTracker<Launcher> ACTIVITY_TRACKER = new ActivityTracker<>();
270
Sunny Goyal2bba4c32015-05-18 15:42:48 -0700271 static final boolean LOGD = false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800272
Winson Chunga2413752012-04-03 14:22:34 -0700273 static final boolean DEBUG_STRICT_MODE = false;
Romain Guy6fefcf12009-06-11 13:07:43 -0700274
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800275 private static final int REQUEST_CREATE_SHORTCUT = 1;
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700276 private static final int REQUEST_CREATE_APPWIDGET = 5;
Jon Mirandac476d6e2017-05-04 16:30:01 -0700277
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700278 private static final int REQUEST_PICK_APPWIDGET = 9;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800279
Michael Jurka8b805b12012-04-18 14:23:14 -0700280 private static final int REQUEST_BIND_APPWIDGET = 11;
Sunny Goyal8a2a63b2018-03-06 22:15:18 -0800281 public static final int REQUEST_BIND_PENDING_APPWIDGET = 12;
282 public static final int REQUEST_RECONFIGURE_APPWIDGET = 13;
Michael Jurka8b805b12012-04-18 14:23:14 -0700283
Sunny Goyal5a1f53b2015-05-27 10:24:24 -0700284 private static final float BOUNCE_ANIMATION_TENSION = 1.3f;
285
Mathew Inwood876a8462013-06-14 14:12:41 +0100286 /**
287 * IntentStarter uses request codes starting with this. This must be greater than all activity
288 * request codes used internally.
289 */
290 protected static final int REQUEST_LAST = 100;
291
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800292 // Type: int
Jeremy Simc94f4b72022-06-10 11:43:37 -0700293 protected static final String RUNTIME_STATE = "launcher.state";
Sunny Goyal2100c782016-08-22 16:00:03 -0700294 // Type: PendingRequestArgs
295 private static final String RUNTIME_STATE_PENDING_REQUEST_ARGS = "launcher.request_args";
Sunny Goyaldedda052019-05-14 15:23:48 -0700296 // Type: int
297 private static final String RUNTIME_STATE_PENDING_REQUEST_CODE = "launcher.request_code";
Sunny Goyal2100c782016-08-22 16:00:03 -0700298 // Type: ActivityResultInfo
299 private static final String RUNTIME_STATE_PENDING_ACTIVITY_RESULT = "launcher.activity_result";
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -0700300 // Type: SparseArray<Parcelable>
301 private static final String RUNTIME_STATE_WIDGET_PANEL = "launcher.widget_panel";
Sunny Goyal12e3f1f2021-07-15 14:31:58 -0700302 // Type int[]
303 private static final String RUNTIME_STATE_CURRENT_SCREEN_IDS = "launcher.current_screen_ids";
Sunny Goyal17c72fb2019-10-14 14:06:38 -0700304
Jeremy Simc94f4b72022-06-10 11:43:37 -0700305 // Type PendingSplitSelectInfo<Parcelable>
306 protected static final String PENDING_SPLIT_SELECT_INFO = "launcher.pending_split_select_info";
307
Tracy Zhoucb93ec52023-03-31 22:51:17 -0700308 public static final String INTENT_ACTION_ALL_APPS_TOGGLE =
309 "launcher.intent_action_all_apps_toggle";
310
vadimt00d42552018-12-11 17:59:36 -0800311 public static final String ON_CREATE_EVT = "Launcher.onCreate";
Sunny Goyal17c72fb2019-10-14 14:06:38 -0700312 public static final String ON_START_EVT = "Launcher.onStart";
313 public static final String ON_RESUME_EVT = "Launcher.onResume";
314 public static final String ON_NEW_INTENT_EVT = "Launcher.onNewIntent";
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800315
Fengjiang Li5a36c172023-04-13 18:18:27 +0000316 private static boolean sIsNewProcess = true;
317
Sunny Goyal35e7d382020-05-08 13:37:58 -0700318 private StateManager<LauncherState> mStateManager;
Patrick Dubroy6b509c12010-08-23 15:08:16 -0700319
Adam Cohenad4e15c2013-10-17 16:21:35 -0700320 private static final int ON_ACTIVITY_RESULT_ANIMATION_DELAY = 500;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800321
Winson Chunga2413752012-04-03 14:22:34 -0700322 // How long to wait before the new-shortcut animation automatically pans the workspace
Jon Mirandaf5197fc2019-09-04 16:55:41 -0700323 @VisibleForTesting public static final int NEW_APPS_PAGE_MOVE_DELAY = 500;
Rajeev Kumar43c0f582017-06-23 15:34:55 -0700324 private static final int NEW_APPS_ANIMATION_INACTIVE_TIMEOUT_SECONDS = 5;
Jon Mirandaf5197fc2019-09-04 16:55:41 -0700325 @Thunk @VisibleForTesting public static final int NEW_APPS_ANIMATION_DELAY = 500;
Winson Chunga2413752012-04-03 14:22:34 -0700326
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -0700327 private static final String DISPLAY_WORKSPACE_TRACE_METHOD_NAME = "DisplayWorkspaceFirstFrame";
328 private static final String DISPLAY_ALL_APPS_TRACE_METHOD_NAME = "DisplayAllApps";
329 public static final int DISPLAY_WORKSPACE_TRACE_COOKIE = 0;
330 public static final int DISPLAY_ALL_APPS_TRACE_COOKIE = 1;
331
Alex Chau0c4e11b2022-07-08 18:41:36 +0100332 private static final FloatProperty<Workspace<?>> WORKSPACE_WIDGET_SCALE =
333 WORKSPACE_SCALE_PROPERTY_FACTORY.get(SCALE_INDEX_WIDGET_TRANSITION);
334 private static final FloatProperty<Hotseat> HOTSEAT_WIDGET_SCALE =
335 HOTSEAT_SCALE_PROPERTY_FACTORY.get(SCALE_INDEX_WIDGET_TRANSITION);
336
Sukesh Ram3f2338a2023-08-28 18:31:54 +0000337 private static final boolean DESKTOP_MODE_SUPPORTED =
Ats Jenk8121e0d2022-12-01 11:34:43 -0800338 "1".equals(Utilities.getSystemProperty("persist.wm.debug.desktop_mode_2", "0"));
339
Sebastian Franco4080fdd2023-09-19 14:17:23 -0700340 KeyboardShortcutsDelegate mKeyboardShortcutsDelegate = new KeyboardShortcutsDelegate(this);
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700341 @Thunk
Shikha Malhotra0f2e1b62022-03-27 21:02:21 +0000342 Workspace<?> mWorkspace;
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700343 @Thunk
344 DragLayer mDragLayer;
Sunny Goyal322d5562015-06-25 19:35:49 -0700345
Sunny Goyal337c81f2019-12-10 12:19:13 -0800346 private WidgetManagerHelper mAppWidgetManager;
Sihua Ma0593a0d2022-10-03 16:01:48 -0700347 private LauncherWidgetHolder mAppWidgetHolder;
Romain Guycbb89e42009-06-08 15:52:54 -0700348
Rajeev Kumar43c0f582017-06-23 15:34:55 -0700349 private final int[] mTmpAddItemCellCoordinates = new int[2];
Michael Jurka0280c3b2010-09-17 15:00:07 -0700350
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700351 @Thunk
352 Hotseat mHotseat;
Adam Cohenf358a4b2013-07-23 16:47:31 -0700353
Sunny Goyal47328fd2016-05-25 18:56:41 -0700354 private DropTargetBar mDropTargetBar;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700355
356 // Main container view for the all apps screen.
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700357 @Thunk
Brian Isganitis1664c9f2022-01-14 23:15:47 -0500358 ActivityAllAppsContainerView<Launcher> mAppsView;
Hyunyoung Song645764e2016-06-06 14:19:02 -0700359 AllAppsTransitionController mAllAppsController;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700360
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400361 // Scrim view for the all apps and overview state.
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700362 @Thunk
363 ScrimView mScrimView;
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400364
Winson Chung8ae41982017-11-10 11:42:13 -0800365 // UI and state for the overview panel
Sunny Goyal7c7be8c2018-03-07 19:58:07 -0800366 private View mOverviewPanel;
Winson Chung8ae41982017-11-10 11:42:13 -0800367
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700368 @Thunk
369 boolean mWorkspaceLoading = true;
Joe Onorato9c1289c2009-08-17 11:03:03 -0400370
Winson Chungc9bf6d42019-10-04 15:33:18 -0700371 // Used to notify when an activity launch has been deferred because launcher is not yet resumed
372 // TODO: See if we can remove this later
373 private Runnable mOnDeferredActivityLaunchCallback;
374
Sunny Goyal527c7d32015-08-28 15:19:36 -0700375 private ViewOnDrawExecutor mPendingExecutor;
Sunny Goyal7b8d63f2022-04-14 16:37:32 -0700376 private OnPreDrawListener mOnInitialBindListener;
Michael Jurka7607c2f2013-04-03 14:33:19 -0700377
Joe Onorato9c1289c2009-08-17 11:03:03 -0400378 private LauncherModel mModel;
Sunny Goyal43bf11d2017-02-02 13:52:53 -0800379 private ModelWriter mModelWriter;
Joe Onorato0589f0f2010-02-08 13:44:00 -0800380 private IconCache mIconCache;
Sunny Goyalae502842016-06-17 08:43:56 -0700381 private LauncherAccessibilityDelegate mAccessibilityDelegate;
Joe Onorato9c1289c2009-08-17 11:03:03 -0400382
Tony Wickham010d2552017-01-20 08:15:28 -0800383 private PopupDataProvider mPopupDataProvider;
Tony Wickhambfbf7f92016-05-19 11:19:39 -0700384
Andras Kloczl55edfe52021-05-14 12:21:30 +0200385 private IntSet mSynchronouslyBoundPages = new IntSet();
Sunny Goyal12e3f1f2021-07-15 14:31:58 -0700386 @NonNull private IntSet mPagesToBindSynchronously = new IntSet();
Adam Cohen1462de32012-07-24 22:34:36 -0700387
Winson Chung46353de2012-02-16 14:05:10 -0800388 // We only want to get the SharedPreferences once since it does an FS stat each time we get
389 // it from the context.
390 private SharedPreferences mSharedPrefs;
Brian Isganitis099945b2022-01-31 18:15:00 -0500391 private OnboardingPrefs<? extends Launcher> mOnboardingPrefs;
Winson Chung46353de2012-02-16 14:05:10 -0800392
Sunny Goyal2100c782016-08-22 16:00:03 -0700393 // Activity result which needs to be processed after workspace has loaded.
394 private ActivityResultInfo mPendingActivityResult;
395 /**
396 * Holds extra information required to handle a result from an external call, like
397 * {@link #startActivityForResult(Intent, int)} or {@link #requestPermissions(String[], int)}
398 */
399 private PendingRequestArgs mPendingRequestArgs;
Sunny Goyaldedda052019-05-14 15:23:48 -0700400 // Request id for any pending activity result
Sunny Goyal210e1742019-10-17 12:05:38 -0700401 protected int mPendingActivityRequestCode = -1;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800402
Tracy Zhou4d7b2442019-12-09 13:42:57 -0800403 private ViewGroupFocusHelper mFocusHandler;
Hyunyoung Song7fb3ccc2017-10-17 15:39:46 -0700404
Sunny Goyal623eddd2018-03-02 12:24:41 -0800405 private RotationHelper mRotationHelper;
Sunny Goyal7779d622015-06-11 16:18:39 -0700406
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700407 protected LauncherOverlayManager mOverlayManager;
Abhilasha Chahalcb329352022-05-31 15:50:53 +0000408 protected DragController mDragController;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700409 // If true, overlay callbacks are deferred
410 private boolean mDeferOverlayCallbacks;
411 private final Runnable mDeferredOverlayCallbacks = this::checkIfOverlayStillDeferred;
412
Riddle Hsu979da642020-09-22 21:52:40 +0800413 protected long mLastTouchUpTime = -1;
Sunny Goyala306e592020-03-24 01:51:41 -0700414 private boolean mTouchInProgress;
Sunny Goyal9b180102020-03-11 10:02:29 -0700415
thiruramc96873c2021-02-11 15:13:47 -0800416 // New InstanceId is assigned to mAllAppsSessionLogId for each AllApps sessions.
417 // When Launcher is not in AllApps state mAllAppsSessionLogId will be null.
418 // User actions within AllApps state are logged with this InstanceId, to recreate AllApps
419 // session on the server side.
420 protected InstanceId mAllAppsSessionLogId;
421 private LauncherState mPrevLauncherState;
422
kholoud mohamedc76b2032021-12-20 16:47:38 +0000423 private StringCache mStringCache;
Becky Qiu4ed3dfc2022-10-19 16:58:22 -0700424 private BaseSearchConfig mBaseSearchConfig;
Fengjiang Li5a36c172023-04-13 18:18:27 +0000425 private StartupLatencyLogger mStartupLatencyLogger;
Sunny Goyal669b71f2023-01-27 14:37:07 -0800426 private CellPosMapper mCellPosMapper = CellPosMapper.DEFAULT;
fbaronc0e687b2023-10-04 12:11:20 -0700427 private boolean mIsFirstPagePinnedItemEnabled = QSB_ON_FIRST_SCREEN
428 && !ENABLE_SMARTSPACE_REMOVAL.get();
Sunny Goyal669b71f2023-01-27 14:37:07 -0800429
Sunny Goyal0ee66472023-08-17 16:19:22 -0700430 private final CannedAnimationCoordinator mAnimationCoordinator =
431 new CannedAnimationCoordinator(this);
432
Vinit Nayak65460402023-08-11 15:40:07 -0700433 private final List<BackPressHandler> mBackPressedHandlers = new ArrayList<>();
434
Sebastian Franco8a3de212023-09-05 18:54:01 -0700435 public static Launcher getLauncher(Context context) {
436 return fromContext(context);
437 }
438
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800439 @Override
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -0700440 @TargetApi(Build.VERSION_CODES.S)
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800441 protected void onCreate(Bundle savedInstanceState) {
Fengjiang Li5a36c172023-04-13 18:18:27 +0000442 mStartupLatencyLogger = createStartupLatencyLogger(
443 sIsNewProcess
444 ? LockedUserState.get(this).isUserUnlockedAtLauncherStartup()
445 ? COLD
446 : COLD_DEVICE_REBOOTING
447 : WARM);
448 sIsNewProcess = false;
449 mStartupLatencyLogger
450 .logStart(LAUNCHER_LATENCY_STARTUP_TOTAL_DURATION)
451 .logStart(LAUNCHER_LATENCY_STARTUP_ACTIVITY_ON_CREATE);
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -0700452 // Only use a hard-coded cookie since we only want to trace this once.
453 if (Utilities.ATLEAST_S) {
454 Trace.beginAsyncSection(
455 DISPLAY_WORKSPACE_TRACE_METHOD_NAME, DISPLAY_WORKSPACE_TRACE_COOKIE);
456 Trace.beginAsyncSection(DISPLAY_ALL_APPS_TRACE_METHOD_NAME,
457 DISPLAY_ALL_APPS_TRACE_COOKIE);
458 }
Sunny Goyal67736672023-06-02 13:35:19 +0000459 TraceHelper.INSTANCE.beginSection(ON_CREATE_EVT);
Winson Chunga2413752012-04-03 14:22:34 -0700460 if (DEBUG_STRICT_MODE) {
461 StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
462 .detectDiskReads()
463 .detectDiskWrites()
464 .detectNetwork() // or .detectAll() for all detectable problems
465 .penaltyLog()
466 .build());
467 StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
468 .detectLeakedSqlLiteObjects()
469 .detectLeakedClosableObjects()
470 .penaltyLog()
471 .penaltyDeath()
472 .build());
473 }
474
Tony Wickhame78a70b2021-03-29 16:45:59 -0700475 if (Utilities.IS_DEBUG_DEVICE && FeatureFlags.NOTIFY_CRASHES.get()) {
476 final String notificationChannelId = "com.android.launcher3.Debug";
477 final String notificationChannelName = "Debug";
478 final String notificationTag = "Debug";
479 final int notificationId = 0;
480
481 NotificationManager notificationManager = getSystemService(NotificationManager.class);
482 notificationManager.createNotificationChannel(new NotificationChannel(
483 notificationChannelId, notificationChannelName,
484 NotificationManager.IMPORTANCE_HIGH));
485
486 Thread.currentThread().setUncaughtExceptionHandler((thread, throwable) -> {
487 String stackTrace = Log.getStackTraceString(throwable);
488
489 Intent shareIntent = new Intent(Intent.ACTION_SEND);
490 shareIntent.setType("text/plain");
491 shareIntent.putExtra(Intent.EXTRA_TEXT, stackTrace);
492 shareIntent = Intent.createChooser(shareIntent, null);
493 PendingIntent sharePendingIntent = PendingIntent.getActivity(
Sunny Goyalcd2ac0f2022-04-14 21:21:47 -0700494 this, 0, shareIntent, FLAG_UPDATE_CURRENT | FLAG_IMMUTABLE);
Tony Wickhame78a70b2021-03-29 16:45:59 -0700495
496 Notification notification = new Notification.Builder(this, notificationChannelId)
497 .setSmallIcon(android.R.drawable.ic_menu_close_clear_cancel)
498 .setContentTitle("Launcher crash detected!")
499 .setStyle(new Notification.BigTextStyle().bigText(stackTrace))
500 .addAction(android.R.drawable.ic_menu_share, "Share", sharePendingIntent)
501 .build();
502 notificationManager.notify(notificationTag, notificationId, notification);
503
504 Thread.UncaughtExceptionHandler defaultUncaughtExceptionHandler =
505 Thread.getDefaultUncaughtExceptionHandler();
506 if (defaultUncaughtExceptionHandler != null) {
507 defaultUncaughtExceptionHandler.uncaughtException(thread, throwable);
508 }
509 });
510 }
511
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800512 super.onCreate(savedInstanceState);
Daniel Sandlere060b0b2013-06-27 21:47:55 -0400513
Sunny Goyal87f784c2017-01-11 10:48:34 -0800514 LauncherAppState app = LauncherAppState.getInstance(this);
Sunny Goyala7a5bf32020-01-05 15:35:29 +0530515 mModel = app.getModel();
Sunny Goyal9d89f752020-06-19 11:09:24 -0700516
Sunny Goyal41d51a02019-05-14 09:44:34 -0700517 mRotationHelper = new RotationHelper(this);
Hyunyoung Song31971a32019-01-27 12:31:12 -0800518 InvariantDeviceProfile idp = app.getInvariantDeviceProfile();
519 initDeviceProfile(idp);
520 idp.addOnChangeListener(this);
Stefan Andonian146701c2022-11-10 23:07:40 +0000521 mSharedPrefs = LauncherPrefs.getPrefs(this);
Joe Onorato0589f0f2010-02-08 13:44:00 -0800522 mIconCache = app.getIconCache();
Sunny Goyal384b5782021-02-09 22:50:02 -0800523 mAccessibilityDelegate = createAccessibilityDelegate();
Adam Cohen2e6da152015-05-06 11:42:25 -0700524
Abhilasha Chahalcb329352022-05-31 15:50:53 +0000525 initDragController();
Hyunyoung Song645764e2016-06-06 14:19:02 -0700526 mAllAppsController = new AllAppsTransitionController(this);
Sunny Goyal35e7d382020-05-08 13:37:58 -0700527 mStateManager = new StateManager<>(this, NORMAL);
Romain Guycbb89e42009-06-08 15:52:54 -0700528
Sunny Goyal35e7d382020-05-08 13:37:58 -0700529 mOnboardingPrefs = createOnboardingPrefs(mSharedPrefs);
Tony Wickham133cd542020-04-08 17:48:41 -0700530
Luca Zuccarini81f5cee2022-10-11 13:02:09 +0000531 // TODO: move the SearchConfig to SearchState when new LauncherState is created.
532 mBaseSearchConfig = new BaseSearchConfig();
533
Schneider Victor-tuliasfb2affa2023-05-26 15:09:41 -0700534 setupViews();
535
Sunny Goyal337c81f2019-12-10 12:19:13 -0800536 mAppWidgetManager = new WidgetManagerHelper(this);
Sihua Ma0593a0d2022-10-03 16:01:48 -0700537 mAppWidgetHolder = createAppWidgetHolder();
538 mAppWidgetHolder.startListening();
Romain Guycbb89e42009-06-08 15:52:54 -0700539
Sunny Goyal9c2b9602020-01-07 13:07:55 -0800540 mPopupDataProvider = new PopupDataProvider(this::updateNotificationDots);
Tony Wickham010d2552017-01-20 08:15:28 -0800541
Sunny Goyale84c5b82019-09-26 17:05:31 -0700542 boolean internalStateHandled = ACTIVITY_TRACKER.handleCreate(this);
Sunny Goyald3864fa2017-11-14 15:06:36 -0800543 if (internalStateHandled) {
Sunny Goyald3864fa2017-11-14 15:06:36 -0800544 if (savedInstanceState != null) {
545 // InternalStateHandler has already set the appropriate state.
546 // We dont need to do anything.
547 savedInstanceState.remove(RUNTIME_STATE);
548 }
549 }
550 restoreState(savedInstanceState);
Sunny Goyalbbece862019-03-01 13:13:52 -0800551 mStateManager.reapplyState();
Winson Chungb63b44c2017-11-10 17:54:44 -0800552
Sunny Goyalfe770c92016-09-27 14:38:58 -0700553 if (savedInstanceState != null) {
Sunny Goyal12e3f1f2021-07-15 14:31:58 -0700554 int[] pageIds = savedInstanceState.getIntArray(RUNTIME_STATE_CURRENT_SCREEN_IDS);
555 if (pageIds != null) {
556 mPagesToBindSynchronously = IntSet.wrap(pageIds);
557 }
Sunny Goyalfe770c92016-09-27 14:38:58 -0700558 }
Sunny Goyald3864fa2017-11-14 15:06:36 -0800559
Fengjiang Li5a36c172023-04-13 18:18:27 +0000560 mStartupLatencyLogger.logWorkspaceLoadStartTime();
Sunny Goyala7a5bf32020-01-05 15:35:29 +0530561 if (!mModel.addCallbacksAndLoad(this)) {
Sunny Goyald3864fa2017-11-14 15:06:36 -0800562 if (!internalStateHandled) {
Sunny Goyal7b8d63f2022-04-14 16:37:32 -0700563 // If we are not binding synchronously, pause drawing until initial bind complete,
564 // so that the system could continue to show the device loading prompt
565 mOnInitialBindListener = Boolean.FALSE::booleanValue;
Sunny Goyald3864fa2017-11-14 15:06:36 -0800566 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800567 }
568
569 // For handling default keys
Sunny Goyalf4aceab2017-12-06 16:16:31 -0800570 setDefaultKeyMode(DEFAULT_KEYS_SEARCH_LOCAL);
Joe Onorato34a0e1b2009-12-14 17:44:51 -0800571
Sunny Goyal9d89f752020-06-19 11:09:24 -0700572 setContentView(getRootView());
Xiaowen Lei3c0f30a2023-04-12 16:59:45 -0700573 ComposeInitializer.initCompose(this);
574
Sunny Goyal7b8d63f2022-04-14 16:37:32 -0700575 if (mOnInitialBindListener != null) {
576 getRootView().getViewTreeObserver().addOnPreDrawListener(mOnInitialBindListener);
577 }
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800578 getRootView().dispatchInsets();
Mario Bertschlera6936942017-05-31 14:48:19 -0700579
Sunny Goyala992ac92023-01-10 17:50:32 -0800580 // Listen for screen turning off
581 ScreenOnTracker.INSTANCE.get(this).addListener(mScreenOnListener);
Sunny Goyal8392c822017-06-20 10:03:56 -0700582 getSystemUiController().updateUiState(SystemUiController.UI_STATE_BASE_WINDOW,
583 Themes.getAttrBoolean(this, R.attr.isWorkspaceDarkText));
Sunny Goyal14b32402017-07-31 10:03:28 -0700584
585 if (mLauncherCallbacks != null) {
586 mLauncherCallbacks.onCreate(savedInstanceState);
587 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700588 mOverlayManager = getDefaultOverlay();
589 PluginManagerWrapper.INSTANCE.get(this).addPluginListener(this,
Sunny Goyal80a071b2021-12-27 13:30:08 +0530590 LauncherOverlayPlugin.class, false /* allowedMultiple */);
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700591
Sunny Goyal623eddd2018-03-02 12:24:41 -0800592 mRotationHelper.initialize();
Sunny Goyal67736672023-06-02 13:35:19 +0000593 TraceHelper.INSTANCE.endSection();
Samuel Fufa41d909f2020-03-20 16:27:09 -0700594
Schneider Victor-tulias8a35c762020-09-03 14:30:10 -0700595 if (Utilities.ATLEAST_R) {
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -0700596 getWindow().setSoftInputMode(LayoutParams.SOFT_INPUT_ADJUST_NOTHING);
Schneider Victor-tulias8a35c762020-09-03 14:30:10 -0700597 }
Stefan Andonian45fc3012022-05-05 22:48:09 +0000598 setTitle(R.string.home_screen);
Fengjiang Li5a36c172023-04-13 18:18:27 +0000599 mStartupLatencyLogger.logEnd(LAUNCHER_LATENCY_STARTUP_ACTIVITY_ON_CREATE);
600 }
601
602 /**
603 * Create {@link StartupLatencyLogger} that only collects launcher startup latency metrics
604 * without sending them anywhere. Child class can override this method to create logger
605 * that overrides {@link StartupLatencyLogger#log()} to report those metrics.
606 */
607 protected StartupLatencyLogger createStartupLatencyLogger(
608 StatsLogManager.StatsLatencyLogger.LatencyType latencyType) {
609 return new StartupLatencyLogger(latencyType);
Adam Cohen9211d422014-10-07 18:14:53 -0700610 }
611
Fengjiang Li6bb8d792023-01-12 16:20:58 -0800612 /**
Fengjiang Lib7860bd2023-03-15 10:50:50 -0700613 * Provide {@link OnBackAnimationCallback} in below order:
Fengjiang Li6bb8d792023-01-12 16:20:58 -0800614 * <ol>
615 * <li> auto cancel action mode handler
616 * <li> drag handler
617 * <li> view handler
Vinit Nayak65460402023-08-11 15:40:07 -0700618 * <li> registered {@link BackPressHandler}
Fengjiang Li6bb8d792023-01-12 16:20:58 -0800619 * <li> state handler
620 * </ol>
621 *
622 * A back gesture (a single click on back button, or a swipe back gesture that contains a series
623 * of swipe events) should be handled by the same handler from above list. For a new back
624 * gesture, a new handler should be regenerated.
625 *
626 * Note that state handler will always be handling the back press event if the previous 3 don't.
627 */
628 @NonNull
Fengjiang Lid0c23592023-04-20 16:42:25 -0700629 @RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
Fengjiang Lib7860bd2023-03-15 10:50:50 -0700630 protected OnBackAnimationCallback getOnBackAnimationCallback() {
Fengjiang Li6bb8d792023-01-12 16:20:58 -0800631 // #1 auto cancel action mode handler
632 if (isInAutoCancelActionMode()) {
633 return this::finishAutoCancelActionMode;
634 }
635
636 // #2 drag handler
637 if (mDragController.isDragging()) {
638 return mDragController::cancelDrag;
639 }
640
641 // #3 view handler
642 AbstractFloatingView topView =
643 AbstractFloatingView.getTopOpenView(Launcher.this);
644 if (topView != null && topView.canHandleBack()) {
645 return topView;
646 }
647
Vinit Nayak65460402023-08-11 15:40:07 -0700648 // #4 Custom back handlers
649 for (BackPressHandler handler : mBackPressedHandlers) {
650 if (handler.canHandleBack()) {
651 return handler;
652 }
653 }
654
655 // #5 state handler
Fengjiang Lib7860bd2023-03-15 10:50:50 -0700656 return new OnBackAnimationCallback() {
Fengjiang Li6bb8d792023-01-12 16:20:58 -0800657 @Override
658 public void onBackInvoked() {
659 onStateBack();
660 }
661
662 @Override
Fengjiang Lib7860bd2023-03-15 10:50:50 -0700663 public void onBackProgressed(@NonNull BackEvent backEvent) {
Fengjiang Li6bb8d792023-01-12 16:20:58 -0800664 mStateManager.getState().onBackProgressed(
Fengjiang Lib7860bd2023-03-15 10:50:50 -0700665 Launcher.this, backEvent.getProgress());
Fengjiang Li6bb8d792023-01-12 16:20:58 -0800666 }
667
668 @Override
669 public void onBackCancelled() {
670 mStateManager.getState().onBackCancelled(Launcher.this);
671 }
672 };
673 }
674
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700675 protected LauncherOverlayManager getDefaultOverlay() {
676 return new LauncherOverlayManager() { };
677 }
678
Brian Isganitis099945b2022-01-31 18:15:00 -0500679 protected OnboardingPrefs<? extends Launcher> createOnboardingPrefs(
680 SharedPreferences sharedPrefs) {
Sunny Goyal35e7d382020-05-08 13:37:58 -0700681 return new OnboardingPrefs<>(this, sharedPrefs);
Tony Wickham133cd542020-04-08 17:48:41 -0700682 }
683
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700684 @Override
Sunny Goyal80a071b2021-12-27 13:30:08 +0530685 public void onPluginConnected(LauncherOverlayPlugin overlayManager, Context context) {
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700686 switchOverlay(() -> overlayManager.createOverlayManager(this, this));
687 }
688
689 @Override
Sunny Goyal80a071b2021-12-27 13:30:08 +0530690 public void onPluginDisconnected(LauncherOverlayPlugin plugin) {
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700691 switchOverlay(this::getDefaultOverlay);
692 }
693
694 private void switchOverlay(Supplier<LauncherOverlayManager> overlaySupplier) {
695 if (mOverlayManager != null) {
696 mOverlayManager.onActivityDestroyed(this);
697 }
698 mOverlayManager = overlaySupplier.get();
699 if (getRootView().isAttachedToWindow()) {
700 mOverlayManager.onAttachedToWindow();
701 }
702 mDeferOverlayCallbacks = true;
703 checkIfOverlayStillDeferred();
704 }
705
706 @Override
Brian Isganitis099945b2022-01-31 18:15:00 -0500707 public void dispatchDeviceProfileChanged() {
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700708 super.dispatchDeviceProfileChanged();
709 mOverlayManager.onDeviceProvideChanged();
710 }
711
Sunny Goyal7779d622015-06-11 16:18:39 -0700712 @Override
Winson Chung8eb49e02018-07-16 13:33:31 -0700713 public void onEnterAnimationComplete() {
714 super.onEnterAnimationComplete();
Sunny Goyalbe8c3402019-05-22 15:17:52 -0700715 mRotationHelper.setCurrentTransitionRequest(REQUEST_NONE);
Sunny Goyal5c20fdd2022-04-05 20:58:03 -0700716 // Starting with Android S, onEnterAnimationComplete is sent immediately
717 // causing the surface to get removed before the animation completed (b/175345344).
718 // Instead we rely on next user touch event to remove the view and optionally a callback
719 // from system from Android T onwards.
720 if (!Utilities.ATLEAST_S) {
721 AbstractFloatingView.closeOpenViews(this, false, TYPE_ICON_SURFACE);
722 }
Winson Chung8eb49e02018-07-16 13:33:31 -0700723 }
724
725 @Override
Jerry Chang09b40242021-08-27 13:29:01 +0800726 public void onMultiWindowModeChanged(boolean isInMultiWindowMode, Configuration newConfig) {
727 super.onMultiWindowModeChanged(isInMultiWindowMode, newConfig);
728 // Always update device profile when multi window mode changed.
729 initDeviceProfile(mDeviceProfile.inv);
730 dispatchDeviceProfileChanged();
731 }
732
Abhilasha Chahalcb329352022-05-31 15:50:53 +0000733 /**
734 * Initializes the drag controller.
735 */
736 protected void initDragController() {
737 mDragController = new LauncherDragController(this);
738 }
739
Sunny Goyal605bcf32018-03-02 15:16:12 -0800740 @Override
Sunny Goyal6e6f7992021-08-24 16:23:29 -0700741 public void onIdpChanged(boolean modelPropertiesChanged) {
Alex Chau360ec032022-08-10 16:11:42 +0100742 onHandleConfigurationChanged();
743 }
744
745 @Override
746 protected void onHandleConfigurationChanged() {
Nicolo' Mazzucatoe120fcf2023-08-04 15:33:15 +0000747 Trace.beginSection("Launcher#onHandleconfigurationChanged");
748 try {
749 if (!initDeviceProfile(mDeviceProfile.inv)) {
750 return;
751 }
752
753 dispatchDeviceProfileChanged();
754 reapplyUi();
755 mDragLayer.recreateControllers();
756
757 // Calling onSaveInstanceState ensures that static cache used by listWidgets is
758 // initialized properly.
759 onSaveInstanceState(new Bundle());
760 mModel.rebindCallbacks();
761 } finally {
762 Trace.endSection();
Alex Chau6209af62022-07-27 14:08:23 +0100763 }
Hyunyoung Song31971a32019-01-27 12:31:12 -0800764 }
765
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400766 public void onAssistantVisibilityChanged(float visibility) {
Sunny Goyal0b5b8d42021-03-31 14:56:47 -0700767 mHotseat.getQsb().setAlpha(1f - visibility);
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400768 }
769
Bill Lina1221bc2021-06-03 01:49:27 +0800770 /**
Alex Chau6209af62022-07-27 14:08:23 +0100771 * Returns {@code true} if a new DeviceProfile is initialized, and {@code false} otherwise.
772 */
773 protected boolean initDeviceProfile(InvariantDeviceProfile idp) {
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800774 // Load configuration-specific DeviceProfile
Alex Chau6209af62022-07-27 14:08:23 +0100775 DeviceProfile deviceProfile = idp.getDeviceProfile(this);
776 if (mDeviceProfile == deviceProfile) {
777 return false;
778 }
779
780 mDeviceProfile = deviceProfile;
Jerry Changbfac46a2021-09-08 08:20:58 +0800781 if (isInMultiWindowMode()) {
782 mDeviceProfile = mDeviceProfile.getMultiWindowProfile(
783 this, getMultiWindowDisplaySize());
784 }
Sunny Goyalae6e3182019-04-30 12:04:37 -0700785
Sunny Goyal59d086c2018-05-07 17:31:40 -0700786 onDeviceProfileInitiated();
Sebastián Franco1f4d56c2023-08-08 03:29:10 +0000787 if (FOLDABLE_SINGLE_PAGE.get() && mDeviceProfile.isTwoPanels) {
Sebastian Franco09589322022-11-02 15:25:58 -0700788 mCellPosMapper = new TwoPanelCellPosMapper(mDeviceProfile.inv.numColumns);
789 } else {
790 mCellPosMapper = CellPosMapper.DEFAULT;
791 }
Sunny Goyal669b71f2023-01-27 14:37:07 -0800792 mModelWriter = mModel.getWriter(getDeviceProfile().isVerticalBarLayout(), true,
793 mCellPosMapper, this);
Alex Chau6209af62022-07-27 14:08:23 +0100794 return true;
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800795 }
796
Adam Cohen9211d422014-10-07 18:14:53 -0700797 private LauncherCallbacks mLauncherCallbacks;
798
Sunny Goyal0b0847b2018-03-14 12:30:11 -0700799 @Override
800 public void invalidateParent(ItemInfo info) {
Jon Mirandae6f3fa42019-03-04 09:14:40 -0800801 if (info.container >= 0) {
Sunny Goyal0b0847b2018-03-14 12:30:11 -0700802 View folderIcon = getWorkspace().getHomescreenIconByItemId(info.container);
Jon Mirandae6f3fa42019-03-04 09:14:40 -0800803 if (folderIcon instanceof FolderIcon && folderIcon.getTag() instanceof FolderInfo) {
Sunny Goyal11a50742019-08-07 09:24:26 -0700804 if (new FolderGridOrganizer(getDeviceProfile().inv)
805 .setFolderInfo((FolderInfo) folderIcon.getTag())
806 .isItemInPreview(info.rank)) {
Jon Mirandae6f3fa42019-03-04 09:14:40 -0800807 folderIcon.invalidate();
808 }
Sunny Goyal0b0847b2018-03-14 12:30:11 -0700809 }
810 }
811 }
812
Adam Cohenc76e1dd2013-11-14 11:09:14 +0000813 /**
Winson Chung557d6ed2011-07-08 15:34:52 -0700814 * Returns whether we should delay spring loaded mode -- for shortcuts and widgets that have
815 * a configuration step, this allows the proper animations to run after other transitions.
816 */
Sunny Goyalefb7e842018-10-04 15:11:00 -0700817 private int completeAdd(
Sunny Goyal2100c782016-08-22 16:00:03 -0700818 int requestCode, Intent intent, int appWidgetId, PendingRequestArgs info) {
Sunny Goyal669b71f2023-01-27 14:37:07 -0800819 CellPos cellPos = getCellPosMapper().mapModelToPresenter(info);
820 int screenId = cellPos.screenId;
821 if (info.container == CONTAINER_DESKTOP) {
Adam Cohen83079e42014-09-19 17:43:08 -0700822 // When the screen id represents an actual screen (as opposed to a rank) we make sure
823 // that the drop page actually exists.
Sunny Goyal669b71f2023-01-27 14:37:07 -0800824 screenId = ensurePendingDropLayoutExists(cellPos.screenId);
Adam Cohen83079e42014-09-19 17:43:08 -0700825 }
Adam Cohendb364c32014-05-20 14:23:40 -0700826
Sunny Goyal2100c782016-08-22 16:00:03 -0700827 switch (requestCode) {
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800828 case REQUEST_CREATE_SHORTCUT:
Sunny Goyal669b71f2023-01-27 14:37:07 -0800829 completeAddShortcut(intent, info.container, screenId,
830 cellPos.cellX, cellPos.cellY, info);
Pinyao Tingc9074272019-11-11 11:51:44 -0800831 announceForAccessibility(R.string.item_added_to_workspace);
Winson Chungb8472bb2011-08-05 13:49:21 -0700832 break;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800833 case REQUEST_CREATE_APPWIDGET:
Sunny Goyal2100c782016-08-22 16:00:03 -0700834 completeAddAppWidget(appWidgetId, info, null, null);
Winson Chungb8472bb2011-08-05 13:49:21 -0700835 break;
Sunny Goyalff572272014-07-23 13:58:07 -0700836 case REQUEST_RECONFIGURE_APPWIDGET:
Sunny Goyal977838b2022-06-27 13:15:41 -0700837 getStatsLogManager().logger().withItemInfo(info).log(LAUNCHER_WIDGET_RECONFIGURED);
Sunny Goyal2100c782016-08-22 16:00:03 -0700838 completeRestoreAppWidget(appWidgetId, LauncherAppWidgetInfo.RESTORE_COMPLETED);
Sunny Goyalff572272014-07-23 13:58:07 -0700839 break;
Sunny Goyald478c832016-04-01 12:04:16 -0700840 case REQUEST_BIND_PENDING_APPWIDGET: {
Sunny Goyal2100c782016-08-22 16:00:03 -0700841 int widgetId = appWidgetId;
842 LauncherAppWidgetInfo widgetInfo =
Sunny Goyald478c832016-04-01 12:04:16 -0700843 completeRestoreAppWidget(widgetId, LauncherAppWidgetInfo.FLAG_UI_NOT_READY);
Sunny Goyal2100c782016-08-22 16:00:03 -0700844 if (widgetInfo != null) {
Sunny Goyald478c832016-04-01 12:04:16 -0700845 // Since the view was just bound, also launch the configure activity if needed
846 LauncherAppWidgetProviderInfo provider = mAppWidgetManager
fbaron30d9e3f2023-08-03 17:03:59 -0700847 .getLauncherAppWidgetInfo(widgetId, info.getTargetComponent());
Sunny Goyal04a324a2017-01-20 21:08:59 -0800848 if (provider != null) {
849 new WidgetAddFlowHandler(provider)
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700850 .startConfigActivity(this, widgetInfo,
851 REQUEST_RECONFIGURE_APPWIDGET);
Sunny Goyald478c832016-04-01 12:04:16 -0700852 }
853 }
854 break;
855 }
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800856 }
Adam Cohendb364c32014-05-20 14:23:40 -0700857 return screenId;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800858 }
859
Adam Cohenc7cd2cb2014-11-17 17:45:34 -0800860 private void handleActivityResult(
Michael Jurka8b805b12012-04-18 14:23:14 -0700861 final int requestCode, final int resultCode, final Intent data) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700862 if (isWorkspaceLoading()) {
863 // process the result once the workspace has loaded.
864 mPendingActivityResult = new ActivityResultInfo(requestCode, resultCode, data);
865 return;
866 }
867 mPendingActivityResult = null;
868
Winson Chunge341d302013-08-16 14:31:00 -0700869 // Reset the startActivity waiting flag
Sunny Goyal2100c782016-08-22 16:00:03 -0700870 final PendingRequestArgs requestArgs = mPendingRequestArgs;
871 setWaitingForResult(null);
872 if (requestArgs == null) {
873 return;
874 }
875
876 final int pendingAddWidgetId = requestArgs.getWidgetId();
Winson Chunge341d302013-08-16 14:31:00 -0700877
Charlie Anderson438d4052023-04-25 14:38:57 -0400878 Runnable exitSpringLoaded = MULTI_SELECT_EDIT_MODE.get() ? null
879 : () -> mStateManager.goToState(NORMAL, SPRING_LOADED_EXIT_DELAY);
Adam Cohenad4e15c2013-10-17 16:21:35 -0700880
Michael Jurka8b805b12012-04-18 14:23:14 -0700881 if (requestCode == REQUEST_BIND_APPWIDGET) {
Winsona1f79d32015-08-05 14:00:45 -0700882 // This is called only if the user did not previously have permissions to bind widgets
Adam Cohenad4e15c2013-10-17 16:21:35 -0700883 final int appWidgetId = data != null ?
Michael Jurka8b805b12012-04-18 14:23:14 -0700884 data.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1) : -1;
885 if (resultCode == RESULT_CANCELED) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700886 completeTwoStageWidgetDrop(RESULT_CANCELED, appWidgetId, requestArgs);
Sunny Goyal6e379fc2020-03-19 16:08:14 -0700887 mWorkspace.removeExtraEmptyScreenDelayed(
888 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false, exitSpringLoaded);
Michael Jurka8b805b12012-04-18 14:23:14 -0700889 } else if (resultCode == RESULT_OK) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700890 addAppWidgetImpl(
891 appWidgetId, requestArgs, null,
Sunny Goyal04a324a2017-01-20 21:08:59 -0800892 requestArgs.getWidgetHandler(),
Sunny Goyal2100c782016-08-22 16:00:03 -0700893 ON_ACTIVITY_RESULT_ANIMATION_DELAY);
Michael Jurka8b805b12012-04-18 14:23:14 -0700894 }
895 return;
896 }
Michael Jurka336fd4f2013-09-12 00:05:02 +0200897
Adam Cohened66b2b2012-01-23 17:28:51 -0800898 boolean isWidgetDrop = (requestCode == REQUEST_PICK_APPWIDGET ||
Sunny Goyal5c97f512015-05-19 16:03:28 -0700899 requestCode == REQUEST_CREATE_APPWIDGET);
Romain Guyaad5ef42009-06-10 02:48:37 -0700900
Adam Cohened66b2b2012-01-23 17:28:51 -0800901 // We have special handling for widgets
902 if (isWidgetDrop) {
Adam Cohen4637b5a2013-11-04 18:21:24 -0800903 final int appWidgetId;
904 int widgetId = data != null ? data.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1)
905 : -1;
906 if (widgetId < 0) {
907 appWidgetId = pendingAddWidgetId;
908 } else {
909 appWidgetId = widgetId;
910 }
911
Adam Cohenad4e15c2013-10-17 16:21:35 -0700912 final int result;
Adam Cohenf0129b12013-11-04 17:57:36 -0800913 if (appWidgetId < 0 || resultCode == RESULT_CANCELED) {
Adam Cohendb364c32014-05-20 14:23:40 -0700914 Log.e(TAG, "Error: appWidgetId (EXTRA_APPWIDGET_ID) was not " +
915 "returned from the widget configuration activity.");
Adam Cohenad4e15c2013-10-17 16:21:35 -0700916 result = RESULT_CANCELED;
Sunny Goyal2100c782016-08-22 16:00:03 -0700917 completeTwoStageWidgetDrop(result, appWidgetId, requestArgs);
Sunny Goyal6e379fc2020-03-19 16:08:14 -0700918 mWorkspace.removeExtraEmptyScreenDelayed(
919 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false,
920 () -> getStateManager().goToState(NORMAL));
Sunny Goyal2100c782016-08-22 16:00:03 -0700921 } else {
Sunny Goyal669b71f2023-01-27 14:37:07 -0800922 CellPos presenterPos = getCellPosMapper().mapModelToPresenter(requestArgs);
923 if (requestArgs.container == CONTAINER_DESKTOP) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700924 // When the screen id represents an actual screen (as opposed to a rank)
925 // we make sure that the drop page actually exists.
Sunny Goyal669b71f2023-01-27 14:37:07 -0800926 int newScreenId = ensurePendingDropLayoutExists(presenterPos.screenId);
927 requestArgs.screenId = getCellPosMapper().mapPresenterToModel(
928 presenterPos.cellX, presenterPos.cellY, newScreenId, CONTAINER_DESKTOP)
929 .screenId;
Adam Cohendb364c32014-05-20 14:23:40 -0700930 }
Sunny Goyal2100c782016-08-22 16:00:03 -0700931 final CellLayout dropLayout =
Sunny Goyal669b71f2023-01-27 14:37:07 -0800932 mWorkspace.getScreenWithId(presenterPos.screenId);
Sunny Goyal2100c782016-08-22 16:00:03 -0700933
934 dropLayout.setDropPending(true);
935 final Runnable onComplete = new Runnable() {
936 @Override
937 public void run() {
938 completeTwoStageWidgetDrop(resultCode, appWidgetId, requestArgs);
939 dropLayout.setDropPending(false);
940 }
941 };
Sunny Goyal6e379fc2020-03-19 16:08:14 -0700942 mWorkspace.removeExtraEmptyScreenDelayed(
943 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false, onComplete);
Winson Chung5aaab772012-04-27 15:24:02 -0700944 }
Adam Cohened66b2b2012-01-23 17:28:51 -0800945 return;
946 }
947
Sunny Goyald478c832016-04-01 12:04:16 -0700948 if (requestCode == REQUEST_RECONFIGURE_APPWIDGET
949 || requestCode == REQUEST_BIND_PENDING_APPWIDGET) {
Sunny Goyalff572272014-07-23 13:58:07 -0700950 if (resultCode == RESULT_OK) {
951 // Update the widget view.
Sunny Goyal2100c782016-08-22 16:00:03 -0700952 completeAdd(requestCode, data, pendingAddWidgetId, requestArgs);
Sunny Goyalff572272014-07-23 13:58:07 -0700953 }
954 // Leave the widget in the pending state if the user canceled the configure.
955 return;
956 }
957
Sunny Goyalaad90582015-07-09 14:22:50 -0700958 if (requestCode == REQUEST_CREATE_SHORTCUT) {
959 // Handle custom shortcuts created using ACTION_CREATE_SHORTCUT.
Sunny Goyal2100c782016-08-22 16:00:03 -0700960 if (resultCode == RESULT_OK && requestArgs.container != ItemInfo.NO_ID) {
961 completeAdd(requestCode, data, -1, requestArgs);
Sunny Goyal6e379fc2020-03-19 16:08:14 -0700962 mWorkspace.removeExtraEmptyScreenDelayed(
963 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false, exitSpringLoaded);
Sunny Goyal2100c782016-08-22 16:00:03 -0700964
Sunny Goyalaad90582015-07-09 14:22:50 -0700965 } else if (resultCode == RESULT_CANCELED) {
Sunny Goyal6e379fc2020-03-19 16:08:14 -0700966 mWorkspace.removeExtraEmptyScreenDelayed(
967 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false, exitSpringLoaded);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800968 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800969 }
Hongming Jind91cb6e2020-01-27 16:23:03 -0800970
Adam Cohened66b2b2012-01-23 17:28:51 -0800971 mDragLayer.clearAnimatedView();
Adam Cohenc7cd2cb2014-11-17 17:45:34 -0800972 }
973
974 @Override
Sunny Goyal64a75aa2017-07-03 13:50:52 -0700975 public void onActivityResult(
Adam Cohenc7cd2cb2014-11-17 17:45:34 -0800976 final int requestCode, final int resultCode, final Intent data) {
Sunny Goyaldedda052019-05-14 15:23:48 -0700977 mPendingActivityRequestCode = -1;
Adam Cohenc7cd2cb2014-11-17 17:45:34 -0800978 handleActivityResult(requestCode, resultCode, data);
Adam Cohened66b2b2012-01-23 17:28:51 -0800979 }
980
Adam Cohendb364c32014-05-20 14:23:40 -0700981 /**
982 * Check to see if a given screen id exists. If not, create it at the end, return the new id.
983 *
984 * @param screenId the screen id to check
985 * @return the new screen, or screenId if it exists
986 */
Sunny Goyalefb7e842018-10-04 15:11:00 -0700987 private int ensurePendingDropLayoutExists(int screenId) {
Sunny Goyal32554d12015-12-03 15:31:25 -0800988 CellLayout dropLayout = mWorkspace.getScreenWithId(screenId);
Adam Cohendb364c32014-05-20 14:23:40 -0700989 if (dropLayout == null) {
990 // it's possible that the add screen was removed because it was
991 // empty and a re-bind occurred
Andras Kloczl408a54f2021-08-28 00:59:08 +0100992 mWorkspace.addExtraEmptyScreens();
993 IntSet emptyPagesAdded = mWorkspace.commitExtraEmptyScreens();
994 return emptyPagesAdded.isEmpty() ? -1 : emptyPagesAdded.getArray().get(0);
Adam Cohendb364c32014-05-20 14:23:40 -0700995 }
Andras Kloczl408a54f2021-08-28 00:59:08 +0100996 return screenId;
Adam Cohendb364c32014-05-20 14:23:40 -0700997 }
998
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700999 @Thunk
1000 void completeTwoStageWidgetDrop(
Sunny Goyal2100c782016-08-22 16:00:03 -07001001 final int resultCode, final int appWidgetId, final PendingRequestArgs requestArgs) {
Sunny Goyal669b71f2023-01-27 14:37:07 -08001002 CellLayout cellLayout = mWorkspace.getScreenWithId(
1003 getCellPosMapper().mapModelToPresenter(requestArgs).screenId);
Adam Cohened66b2b2012-01-23 17:28:51 -08001004 Runnable onCompleteRunnable = null;
1005 int animationType = 0;
1006
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001007 AppWidgetHostView boundWidget = null;
Adam Cohened66b2b2012-01-23 17:28:51 -08001008 if (resultCode == RESULT_OK) {
1009 animationType = Workspace.COMPLETE_TWO_STAGE_WIDGET_DROP_ANIMATION;
Sihua Ma0593a0d2022-10-03 16:01:48 -07001010 final AppWidgetHostView layout = mAppWidgetHolder.createView(this, appWidgetId,
Sunny Goyal04a324a2017-01-20 21:08:59 -08001011 requestArgs.getWidgetHandler().getProviderInfo(this));
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001012 boundWidget = layout;
Charlie Anderson438d4052023-04-25 14:38:57 -04001013 onCompleteRunnable = () -> {
1014 completeAddAppWidget(appWidgetId, requestArgs, layout, null);
1015 if (!isInState(EDIT_MODE)) {
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001016 mStateManager.goToState(NORMAL, SPRING_LOADED_EXIT_DELAY);
Adam Cohened66b2b2012-01-23 17:28:51 -08001017 }
1018 };
1019 } else if (resultCode == RESULT_CANCELED) {
Sihua Ma0593a0d2022-10-03 16:01:48 -07001020 mAppWidgetHolder.deleteAppWidgetId(appWidgetId);
Adam Cohened66b2b2012-01-23 17:28:51 -08001021 animationType = Workspace.CANCEL_TWO_STAGE_WIDGET_DROP_ANIMATION;
Adam Cohened66b2b2012-01-23 17:28:51 -08001022 }
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001023 if (mDragLayer.getAnimatedView() != null) {
Sunny Goyal2100c782016-08-22 16:00:03 -07001024 mWorkspace.animateWidgetDrop(requestArgs, cellLayout,
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001025 (DragView) mDragLayer.getAnimatedView(), onCompleteRunnable,
1026 animationType, boundWidget, true);
Adam Cohenad4e15c2013-10-17 16:21:35 -07001027 } else if (onCompleteRunnable != null) {
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001028 // The animated view may be null in the case of a rotation during widget configuration
1029 onCompleteRunnable.run();
1030 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001031 }
1032
1033 @Override
Michael Jurkacd496d72013-04-11 11:32:45 -07001034 protected void onStop() {
1035 super.onStop();
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001036 if (mDeferOverlayCallbacks) {
1037 checkIfOverlayStillDeferred();
1038 } else {
1039 mOverlayManager.onActivityStopped(this);
Adam Cohen9211d422014-10-07 18:14:53 -07001040 }
Hyunyoung Song5ee7c132021-05-11 13:52:36 -07001041 hideKeyboard();
Hyunyoung Song95786e02020-09-15 00:34:10 -07001042 logStopAndResume(false /* isResume */);
Sihua Ma0593a0d2022-10-03 16:01:48 -07001043 mAppWidgetHolder.setActivityStarted(false);
Schneider Victor-tulias5173fd82021-10-19 14:47:23 -07001044 NotificationListener.removeNotificationsChangedListener(getPopupDataProvider());
Winson Chung7c500162023-06-14 18:58:27 +00001045 FloatingIconView.resetIconLoadResult();
Michael Jurkacd496d72013-04-11 11:32:45 -07001046 }
1047
1048 @Override
1049 protected void onStart() {
Sunny Goyal67736672023-06-02 13:35:19 +00001050 TraceHelper.INSTANCE.beginSection(ON_START_EVT);
Michael Jurkacd496d72013-04-11 11:32:45 -07001051 super.onStart();
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001052 if (!mDeferOverlayCallbacks) {
1053 mOverlayManager.onActivityStarted(this);
Adam Cohen9211d422014-10-07 18:14:53 -07001054 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001055
Sihua Ma0593a0d2022-10-03 16:01:48 -07001056 mAppWidgetHolder.setActivityStarted(true);
Sunny Goyal67736672023-06-02 13:35:19 +00001057 TraceHelper.INSTANCE.endSection();
Michael Jurkacd496d72013-04-11 11:32:45 -07001058 }
1059
Sunny Goyal35e7d382020-05-08 13:37:58 -07001060 @Override
1061 @CallSuper
1062 protected void onDeferredResumed() {
Hyunyoung Song95786e02020-09-15 00:34:10 -07001063 logStopAndResume(true /* isResume */);
Sunny Goyala002c6c2019-02-12 16:20:10 -08001064
Sunny Goyal35e7d382020-05-08 13:37:58 -07001065 // Process any items that were added while Launcher was away.
Sunny Goyal60e68c92020-08-12 13:59:27 -07001066 ItemInstallQueue.INSTANCE.get(this)
1067 .resumeModelPush(FLAG_ACTIVITY_PAUSED);
Sunny Goyale9c6f4c2019-05-30 11:35:25 -07001068
Sunny Goyal35e7d382020-05-08 13:37:58 -07001069 // Refresh shortcuts if the permission changed.
Sunny Goyal8b74cc72020-07-27 17:50:33 -07001070 mModel.validateModelDataOnResume();
Sunny Goyale9c6f4c2019-05-30 11:35:25 -07001071
Sunny Goyal35e7d382020-05-08 13:37:58 -07001072 // Set the notification listener and fetch updated notifications when we resume
Schneider Victor-tulias5173fd82021-10-19 14:47:23 -07001073 NotificationListener.addNotificationsChangedListener(mPopupDataProvider);
Winson Chung87583112019-06-10 14:20:58 -07001074
Sunny Goyal35e7d382020-05-08 13:37:58 -07001075 DiscoveryBounce.showForHomeIfNeeded(this);
Sihua Ma0593a0d2022-10-03 16:01:48 -07001076 mAppWidgetHolder.setActivityResumed(true);
Sunny Goyaldedda052019-05-14 15:23:48 -07001077 }
1078
Hyunyoung Song95786e02020-09-15 00:34:10 -07001079 private void logStopAndResume(boolean isResume) {
Hyunyoung Song77e29772020-08-25 00:53:48 -07001080 if (mPendingExecutor != null) return;
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001081 int pageIndex = mWorkspace.isOverlayShown() ? -1 : mWorkspace.getCurrentPage();
Hyunyoung Song95786e02020-09-15 00:34:10 -07001082 int statsLogOrdinal = mStateManager.getState().statsLogOrdinal;
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001083
1084 StatsLogManager.EventEnum event;
1085 StatsLogManager.StatsLogger logger = getStatsLogManager().logger();
Hyunyoung Song95786e02020-09-15 00:34:10 -07001086 if (isResume) {
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001087 logger.withSrcState(LAUNCHER_STATE_BACKGROUND)
Hyunyoung Song95786e02020-09-15 00:34:10 -07001088 .withDstState(mStateManager.getState().statsLogOrdinal);
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001089 event = LAUNCHER_ONRESUME;
1090 } else { /* command == Action.Command.STOP */
Hyunyoung Song95786e02020-09-15 00:34:10 -07001091 logger.withSrcState(mStateManager.getState().statsLogOrdinal)
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001092 .withDstState(LAUNCHER_STATE_BACKGROUND);
1093 event = LAUNCHER_ONSTOP;
1094 }
1095
Hyunyoung Song95786e02020-09-15 00:34:10 -07001096 if (statsLogOrdinal == LAUNCHER_STATE_HOME && mWorkspace != null) {
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001097 logger.withContainerInfo(LauncherAtom.ContainerInfo.newBuilder()
1098 .setWorkspace(
1099 LauncherAtom.WorkspaceContainer.newBuilder()
1100 .setPageIndex(pageIndex)).build());
Becky Qiubfc2da12019-08-01 11:09:38 -07001101 }
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001102 logger.log(event);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001103 }
Becky Qiubfc2da12019-08-01 11:09:38 -07001104
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001105 private void scheduleDeferredCheck() {
1106 mHandler.removeCallbacks(mDeferredOverlayCallbacks);
1107 postAsyncCallback(mHandler, mDeferredOverlayCallbacks);
1108 }
1109
1110 private void checkIfOverlayStillDeferred() {
1111 if (!mDeferOverlayCallbacks) {
1112 return;
1113 }
Sunny Goyal8f965462020-04-23 19:00:36 -07001114 if (isStarted() && (!hasBeenResumed()
1115 || mStateManager.getState().hasFlag(FLAG_NON_INTERACTIVE))) {
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001116 return;
1117 }
1118 mDeferOverlayCallbacks = false;
1119
1120 // Move the client to the correct state. Calling the same method twice is no-op.
1121 if (isStarted()) {
1122 mOverlayManager.onActivityStarted(this);
1123 }
1124 if (hasBeenResumed()) {
1125 mOverlayManager.onActivityResumed(this);
1126 } else {
1127 mOverlayManager.onActivityPaused(this);
1128 }
1129 if (!isStarted()) {
1130 mOverlayManager.onActivityStopped(this);
1131 }
1132 }
1133
1134 public void deferOverlayCallbacksUntilNextResumeOrStop() {
1135 mDeferOverlayCallbacks = true;
1136 }
1137
Sunny Goyal35e7d382020-05-08 13:37:58 -07001138 @Override
Winson Chungef528762019-09-06 12:05:52 -07001139 public void onStateSetStart(LauncherState state) {
Sunny Goyal35e7d382020-05-08 13:37:58 -07001140 super.onStateSetStart(state);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001141 if (mDeferOverlayCallbacks) {
1142 scheduleDeferredCheck();
Sunny Goyale9c6f4c2019-05-30 11:35:25 -07001143 }
Sunny Goyal210e1742019-10-17 12:05:38 -07001144 addActivityFlags(ACTIVITY_STATE_TRANSITION_ACTIVE);
Sunny Goyal8f965462020-04-23 19:00:36 -07001145
Charlie Anderson438d4052023-04-25 14:38:57 -04001146 if (state == SPRING_LOADED || state == EDIT_MODE) {
Sunny Goyal8f965462020-04-23 19:00:36 -07001147 // Prevent any Un/InstallShortcutReceivers from updating the db while we are
1148 // not on homescreen
Sunny Goyal60e68c92020-08-12 13:59:27 -07001149 ItemInstallQueue.INSTANCE.get(this).pauseModelPush(FLAG_DRAG_AND_DROP);
Sunny Goyal8f965462020-04-23 19:00:36 -07001150 getRotationHelper().setCurrentStateRequest(REQUEST_LOCK);
1151
1152 mWorkspace.showPageIndicatorAtCurrentScroll();
1153 mWorkspace.setClipChildren(false);
1154 }
1155 // When multiple pages are visible, show persistent page indicator
1156 mWorkspace.getPageIndicator().setShouldAutoHide(!state.hasFlag(FLAG_MULTI_PAGE));
thiruram0eabc782021-04-02 14:30:10 -07001157
thiruramc96873c2021-02-11 15:13:47 -08001158 mPrevLauncherState = mStateManager.getCurrentStableState();
thiruram0eabc782021-04-02 14:30:10 -07001159 if (mPrevLauncherState != state && ALL_APPS.equals(state)
1160 // Making sure mAllAppsSessionLogId is null to avoid double logging.
1161 && mAllAppsSessionLogId == null) {
1162 // creates new instance ID since new all apps session is started.
1163 mAllAppsSessionLogId = new InstanceIdSequence().newInstanceId();
Thiru Ramasamy694407c2022-03-08 12:11:24 -08001164 if (getAllAppsEntryEvent().isPresent()) {
1165 getStatsLogManager().logger()
1166 .withContainerInfo(ContainerInfo.newBuilder()
1167 .setWorkspace(WorkspaceContainer.newBuilder()
1168 .setPageIndex(getWorkspace().getCurrentPage())).build())
1169 .log(getAllAppsEntryEvent().get());
1170 }
thiruram0eabc782021-04-02 14:30:10 -07001171 }
Sunny Goyal1eb11242022-09-09 17:14:45 -07001172 updateDisallowBack();
Sunny Goyaldedda052019-05-14 15:23:48 -07001173 }
1174
Thiru Ramasamy5fbac632022-01-28 15:05:36 -08001175 /**
1176 * Returns {@link EventEnum} that should be logged when Launcher enters into AllApps state.
1177 */
Thiru Ramasamy694407c2022-03-08 12:11:24 -08001178 protected Optional<EventEnum> getAllAppsEntryEvent() {
1179 return Optional.of(FeatureFlags.ENABLE_DEVICE_SEARCH.get()
Thiru Ramasamy5fbac632022-01-28 15:05:36 -08001180 ? LAUNCHER_ALLAPPS_ENTRY_WITH_DEVICE_SEARCH
Thiru Ramasamy694407c2022-03-08 12:11:24 -08001181 : LAUNCHER_ALLAPPS_ENTRY);
Thiru Ramasamy5fbac632022-01-28 15:05:36 -08001182 }
1183
Sunny Goyal35e7d382020-05-08 13:37:58 -07001184 @Override
Winson Chungef528762019-09-06 12:05:52 -07001185 public void onStateSetEnd(LauncherState state) {
Sunny Goyalfee1b252020-12-14 12:30:38 -08001186 super.onStateSetEnd(state);
Sihua Ma0593a0d2022-10-03 16:01:48 -07001187 getAppWidgetHolder().setStateIsNormal(state == LauncherState.NORMAL);
Sunny Goyal8f965462020-04-23 19:00:36 -07001188 getWorkspace().setClipChildren(!state.hasFlag(FLAG_MULTI_PAGE));
1189
Winson Chungef528762019-09-06 12:05:52 -07001190 finishAutoCancelActionMode();
Sunny Goyal210e1742019-10-17 12:05:38 -07001191 removeActivityFlags(ACTIVITY_STATE_TRANSITION_ACTIVE);
Sunny Goyal8f965462020-04-23 19:00:36 -07001192
1193 // dispatch window state changed
1194 getWindow().getDecorView().sendAccessibilityEvent(TYPE_WINDOW_STATE_CHANGED);
1195 AccessibilityManagerCompat.sendStateEventToTest(this, state.ordinal);
1196
1197 if (state == NORMAL) {
1198 // Re-enable any Un/InstallShortcutReceiver and now process any queued items
Sunny Goyal60e68c92020-08-12 13:59:27 -07001199 ItemInstallQueue.INSTANCE.get(this)
1200 .resumeModelPush(FLAG_DRAG_AND_DROP);
Sunny Goyal8f965462020-04-23 19:00:36 -07001201
1202 // Clear any rotation locks when going to normal state
1203 getRotationHelper().setCurrentStateRequest(REQUEST_NONE);
1204 }
thiruramc96873c2021-02-11 15:13:47 -08001205
thiruramea56f842021-06-02 16:02:37 -07001206 if (ALL_APPS.equals(mPrevLauncherState) && !ALL_APPS.equals(state)
thiruram0eabc782021-04-02 14:30:10 -07001207 // Making sure mAllAppsSessionLogId is not null to avoid double logging.
thiruramc96873c2021-02-11 15:13:47 -08001208 && mAllAppsSessionLogId != null) {
Samuel Fuface820f52021-06-18 17:23:48 -05001209 getAppsView().reset(false);
Thiru Ramasamy694407c2022-03-08 12:11:24 -08001210 getAllAppsExitEvent().ifPresent(getStatsLogManager().logger()::log);
thiruramc96873c2021-02-11 15:13:47 -08001211 mAllAppsSessionLogId = null;
1212 }
Winson Chungef528762019-09-06 12:05:52 -07001213 }
1214
Thiru Ramasamy694407c2022-03-08 12:11:24 -08001215 /**
1216 * Returns {@link EventEnum} that should be logged when Launcher exists from AllApps state.
1217 */
1218 protected Optional<EventEnum> getAllAppsExitEvent() {
1219 return Optional.of(LAUNCHER_ALLAPPS_EXIT);
1220 }
1221
Michael Jurkacd496d72013-04-11 11:32:45 -07001222 @Override
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001223 protected void onResume() {
Sunny Goyal67736672023-06-02 13:35:19 +00001224 TraceHelper.INSTANCE.beginSection(ON_RESUME_EVT);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001225 super.onResume();
Sunny Goyalfca6bc92017-09-28 16:28:34 -07001226
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001227 if (mDeferOverlayCallbacks) {
1228 scheduleDeferredCheck();
1229 } else {
1230 mOverlayManager.onActivityResumed(this);
Adam Cohen9211d422014-10-07 18:14:53 -07001231 }
Mario Bertschler0fc6f682017-02-17 12:16:13 -08001232
Jon Mirandaa82a7dc2022-05-10 11:48:32 -07001233 DragView.removeAllViews(this);
Sunny Goyal67736672023-06-02 13:35:19 +00001234 TraceHelper.INSTANCE.endSection();
Adam Cohen06dff352012-06-01 17:17:08 -07001235 }
1236
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001237 @Override
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001238 protected void onPause() {
Winson Chung997a9232013-07-24 15:33:46 -07001239 // Ensure that items added to Launcher are queued until Launcher returns
Sunny Goyal60e68c92020-08-12 13:59:27 -07001240 ItemInstallQueue.INSTANCE.get(this).pauseModelPush(FLAG_ACTIVITY_PAUSED);
Winson Chung997a9232013-07-24 15:33:46 -07001241
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001242 super.onPause();
Joe Onorato24b6fd82009-11-12 13:47:09 -08001243 mDragController.cancelDrag();
Sunny Goyal9b180102020-03-11 10:02:29 -07001244 mLastTouchUpTime = -1;
Hyunyoung Song497708c2019-05-01 16:16:53 -07001245 mDropTargetBar.animateToVisibility(false);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001246
1247 if (!mDeferOverlayCallbacks) {
1248 mOverlayManager.onActivityPaused(this);
Adam Cohenbffe7452013-07-22 18:21:45 -07001249 }
Sihua Ma0593a0d2022-10-03 16:01:48 -07001250 mAppWidgetHolder.setActivityResumed(false);
Adam Cohenbffe7452013-07-22 18:21:45 -07001251 }
1252
Lucas Dupin87d75202021-07-28 10:24:54 -07001253 /**
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001254 * Restores the previous state, if it exists.
1255 *
1256 * @param savedState The previous state.
1257 */
1258 private void restoreState(Bundle savedState) {
1259 if (savedState == null) {
1260 return;
1261 }
1262
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001263 int stateOrdinal = savedState.getInt(RUNTIME_STATE, NORMAL.ordinal);
Sunny Goyalf9403d92017-10-18 10:55:56 -07001264 LauncherState[] stateValues = LauncherState.values();
1265 LauncherState state = stateValues[stateOrdinal];
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08001266
1267 NonConfigInstance lastInstance = (NonConfigInstance) getLastNonConfigurationInstance();
1268 boolean forceRestore = lastInstance != null
1269 && (lastInstance.config.diff(mOldConfig) & CONFIG_UI_MODE) != 0;
1270 if (forceRestore || !state.shouldDisableRestore()) {
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001271 mStateManager.goToState(state, false /* animated */);
Joe Onorato3a8820b2009-11-10 15:06:42 -08001272 }
1273
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001274 PendingRequestArgs requestArgs = savedState.getParcelable(
1275 RUNTIME_STATE_PENDING_REQUEST_ARGS);
Sunny Goyal2100c782016-08-22 16:00:03 -07001276 if (requestArgs != null) {
1277 setWaitingForResult(requestArgs);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001278 }
Sunny Goyaldedda052019-05-14 15:23:48 -07001279 mPendingActivityRequestCode = savedState.getInt(RUNTIME_STATE_PENDING_REQUEST_CODE);
Sunny Goyal2100c782016-08-22 16:00:03 -07001280
1281 mPendingActivityResult = savedState.getParcelable(RUNTIME_STATE_PENDING_ACTIVITY_RESULT);
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001282
1283 SparseArray<Parcelable> widgetsState =
1284 savedState.getSparseParcelableArray(RUNTIME_STATE_WIDGET_PANEL);
1285 if (widgetsState != null) {
1286 WidgetsFullSheet.show(this, false).restoreHierarchyState(widgetsState);
1287 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001288 }
1289
1290 /**
1291 * Finds all the views we need and configure them properly.
1292 */
Tony Wickham04fca162020-02-05 15:06:52 -08001293 protected void setupViews() {
Fengjiang Li5a36c172023-04-13 18:18:27 +00001294 mStartupLatencyLogger.logStart(LAUNCHER_LATENCY_STARTUP_VIEW_INFLATION);
Becky Qiu3aec5d52022-09-16 11:17:50 -07001295 inflateRootView(R.layout.launcher);
Fengjiang Li5a36c172023-04-13 18:18:27 +00001296 mStartupLatencyLogger.logEnd(LAUNCHER_LATENCY_STARTUP_VIEW_INFLATION);
1297
Sunny Goyalcc96aa12018-01-11 09:56:07 -08001298 mDragLayer = findViewById(R.id.drag_layer);
Sunny Goyal3333b0c2016-05-09 20:43:21 -07001299 mFocusHandler = mDragLayer.getFocusIndicatorHelper();
Sunny Goyal966d9012017-06-06 16:43:59 -07001300 mWorkspace = mDragLayer.findViewById(R.id.workspace);
Sunny Goyald0a6ae72016-06-16 12:29:03 -07001301 mWorkspace.initParentViews(mDragLayer);
Sreyas321bfae2020-02-21 17:53:02 -08001302 mOverviewPanel = findViewById(R.id.overview_panel);
Sunny Goyal7c7be8c2018-03-07 19:58:07 -08001303 mHotseat = findViewById(R.id.hotseat);
Adam Cohenb66675a2020-05-15 16:16:17 -07001304 mHotseat.setWorkspace(mWorkspace);
Craig Mautner360310b2012-10-26 15:13:08 -07001305
Winson Chung4c98d922011-05-31 16:50:48 -07001306 // Setup the drag layer
Sunny Goyal5d1873a2018-05-08 11:10:44 -07001307 mDragLayer.setup(mDragController, mWorkspace);
Winson Chung4c98d922011-05-31 16:50:48 -07001308
Hyunyoung Song645764e2016-06-06 14:19:02 -07001309 mWorkspace.setup(mDragController);
Winsonc7d2e832016-07-28 12:24:55 -07001310 // Until the workspace is bound, ensure that we keep the wallpaper offset locked to the
1311 // default state, otherwise we will update to the wrong offsets in RTL
1312 mWorkspace.lockWallpaperToDefaultPage();
fbaronc0e687b2023-10-04 12:11:20 -07001313 if (!ENABLE_SMARTSPACE_REMOVAL.get()) {
1314 mWorkspace.bindAndInitFirstWorkspaceScreen();
1315 }
Hyunyoung Song645764e2016-06-06 14:19:02 -07001316 mDragController.addDragListener(mWorkspace);
Winson Chung4c98d922011-05-31 16:50:48 -07001317
Tony Wickham34d2c912015-09-11 09:27:58 -07001318 // Get the search/delete/uninstall bar
Rajeev Kumar43c0f582017-06-23 15:34:55 -07001319 mDropTargetBar = mDragLayer.findViewById(R.id.drop_target_bar);
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07001320
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001321 // Setup Apps
1322 mAppsView = findViewById(R.id.apps_view);
Fengjiang Lid080b982023-02-01 15:30:30 -08001323 mAppsView.setAllAppsTransitionController(mAllAppsController);
Craig Mautner360310b2012-10-26 15:13:08 -07001324
Govinda Wassermanc06e1512019-04-09 09:56:53 -04001325 // Setup Scrim
1326 mScrimView = findViewById(R.id.scrim_view);
1327
Winson Chung3d503fb2011-07-13 17:25:49 -07001328 // Setup the drag controller (drop targets have to be added in reverse order in priority)
Sunny Goyal47328fd2016-05-25 18:56:41 -07001329 mDropTargetBar.setup(mDragController);
Samuel Fufaacebd1f2021-05-06 10:02:03 -05001330 mAllAppsController.setupViews(mScrimView, mAppsView);
Federico Baron3f255eb2022-12-22 14:40:58 -08001331
fbaron80b0ce82023-09-27 16:23:15 -07001332 mWorkspace.getPageIndicator().setShouldAutoHide(true);
1333 mWorkspace.getPageIndicator().setPaintColor(Themes.getAttrBoolean(
1334 this, R.attr.isWorkspaceDarkText) ? Color.BLACK : Color.WHITE);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001335 }
1336
Federico Baron7539d762022-09-29 09:47:04 -07001337 @Override
1338 public View onCreateView(View parent, String name, Context context, AttributeSet attrs) {
fbaron80b0ce82023-09-27 16:23:15 -07001339 if (WorkspacePageIndicator.class.getName().equals(name)) {
Federico Baron7539d762022-09-29 09:47:04 -07001340 return LayoutInflater.from(context).inflate(R.layout.page_indicator_dots,
1341 (ViewGroup) parent, false);
1342 }
1343 return super.onCreateView(parent, name, context, attrs);
1344 }
1345
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001346 /**
1347 * Creates a view representing a shortcut.
1348 *
1349 * @param info The data structure describing the shortcut.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001350 */
Sunny Goyal95899162019-03-27 16:03:06 -07001351 View createShortcut(WorkspaceItemInfo info) {
Schneider Victor-tulias9f922d32022-04-27 16:39:29 -07001352 // This can be called before PagedView#pageScrollsInitialized returns true, so use the
1353 // first page, which we always assume to be present.
1354 return createShortcut((ViewGroup) mWorkspace.getChildAt(0), info);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001355 }
1356
1357 /**
1358 * Creates a view representing a shortcut inflated from the specified resource.
1359 *
Schneider Victor-tulias9f922d32022-04-27 16:39:29 -07001360 * @param parent The group the shortcut belongs to. This is not necessarily the group where
1361 * the shortcut should be added.
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001362 * @param info The data structure describing the shortcut.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001363 * @return A View inflated from layoutResId.
1364 */
Fengjiang Li080f9322023-07-12 13:33:54 -07001365 public View createShortcut(@Nullable ViewGroup parent, WorkspaceItemInfo info) {
1366 BubbleTextView favorite =
1367 (BubbleTextView) LayoutInflater.from(parent != null ? parent.getContext() : this)
1368 .inflate(R.layout.app_icon, parent, false);
Sunny Goyal95899162019-03-27 16:03:06 -07001369 favorite.applyFromWorkspaceItem(info);
Tracy Zhouba0b5952022-10-14 01:28:07 -07001370 favorite.setOnClickListener(getItemOnClickListener());
Sunny Goyaldcbcc862014-08-12 15:58:36 -07001371 favorite.setOnFocusChangeListener(mFocusHandler);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001372 return favorite;
1373 }
1374
1375 /**
Jon Mirandac476d6e2017-05-04 16:30:01 -07001376 * Add a shortcut to the workspace or to a Folder.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001377 *
1378 * @param data The intent describing the shortcut.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001379 */
sfufa@google.comd0a33232021-09-19 15:59:36 -07001380 protected void completeAddShortcut(Intent data, int container, int screenId, int cellX,
Sunny Goyalfb5096d2016-09-08 14:32:06 -07001381 int cellY, PendingRequestArgs args) {
Holly Sun35b99602023-06-28 15:14:02 -07001382 if (args.getRequestCode() != REQUEST_CREATE_SHORTCUT) {
Sunny Goyalfb5096d2016-09-08 14:32:06 -07001383 return;
1384 }
Adam Cohen558baaf2011-08-15 15:22:57 -07001385
Jon Mirandac476d6e2017-05-04 16:30:01 -07001386 int[] cellXY = mTmpAddItemCellCoordinates;
1387 CellLayout layout = getCellLayout(container, screenId);
1388
Sunny Goyaleaf7a952020-07-29 16:54:20 -07001389 WorkspaceItemInfo info = PinRequestHelper.createWorkspaceItemFromPinItemRequest(
Sunny Goyale7b00122019-10-02 16:13:34 -07001390 this, PinRequestHelper.getPinItemRequest(data), 0);
Sunny Goyal782f0c92017-01-19 10:27:54 -08001391 if (info == null) {
Sunny Goyal84b48d82023-03-29 16:52:27 -07001392 Log.e(TAG, "Unable to parse a valid shortcut result");
1393 return;
Sunny Goyal782f0c92017-01-19 10:27:54 -08001394 }
1395
Jon Mirandac476d6e2017-05-04 16:30:01 -07001396 if (container < 0) {
1397 // Adding a shortcut to the Workspace.
1398 final View view = createShortcut(info);
1399 boolean foundCellSpan = false;
1400 // First we check if we already know the exact location where we want to add this item.
1401 if (cellX >= 0 && cellY >= 0) {
1402 cellXY[0] = cellX;
1403 cellXY[1] = cellY;
1404 foundCellSpan = true;
Adam Cohen558baaf2011-08-15 15:22:57 -07001405
Hyunyoung Song1ae42422020-01-26 23:25:14 -08001406 DragObject dragObject = new DragObject(getApplicationContext());
1407 dragObject.dragInfo = info;
Jon Mirandac476d6e2017-05-04 16:30:01 -07001408 // If appropriate, either create a folder or add to an existing folder
1409 if (mWorkspace.createUserFolderIfNecessary(view, container, layout, cellXY, 0,
Hyunyoung Song1ae42422020-01-26 23:25:14 -08001410 true, dragObject)) {
Jon Mirandac476d6e2017-05-04 16:30:01 -07001411 return;
1412 }
Jon Mirandac476d6e2017-05-04 16:30:01 -07001413 if (mWorkspace.addToExistingFolderIfNecessary(view, layout, cellXY, 0, dragObject,
1414 true)) {
1415 return;
1416 }
1417 } else {
1418 foundCellSpan = layout.findCellForSpan(cellXY, 1, 1);
1419 }
1420
1421 if (!foundCellSpan) {
Yogisha Dixit104d09f2021-07-19 14:05:17 +01001422 mWorkspace.onNoCellFound(layout, info, /* logInstanceId= */ null);
Adam Cohen558baaf2011-08-15 15:22:57 -07001423 return;
1424 }
Jon Mirandac476d6e2017-05-04 16:30:01 -07001425
1426 getModelWriter().addItemToDatabase(info, container, screenId, cellXY[0], cellXY[1]);
1427 mWorkspace.addInScreen(view, info);
Michael Jurkad3ef3062010-11-23 16:23:58 -08001428 } else {
Jon Mirandac476d6e2017-05-04 16:30:01 -07001429 // Adding a shortcut to a Folder.
Sunny Goyale29897f52017-07-20 10:09:42 -07001430 FolderIcon folderIcon = findFolderIcon(container);
Jon Mirandac476d6e2017-05-04 16:30:01 -07001431 if (folderIcon != null) {
1432 FolderInfo folderInfo = (FolderInfo) folderIcon.getTag();
1433 folderInfo.add(info, args.rank, false);
1434 } else {
Sunny Goyale29897f52017-07-20 10:09:42 -07001435 Log.e(TAG, "Could not find folder with id " + container + " to add shortcut.");
Jon Mirandac476d6e2017-05-04 16:30:01 -07001436 }
Michael Jurka0280c3b2010-09-17 15:00:07 -07001437 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001438 }
1439
Tony Wickhamc7cbf252021-05-24 15:46:48 -07001440 @Override
1441 public @Nullable FolderIcon findFolderIcon(final int folderIconId) {
Sunny Goyal83fd25e2018-07-09 16:47:01 -07001442 return (FolderIcon) mWorkspace.getHomescreenIconByItemId(folderIconId);
Sunny Goyale29897f52017-07-20 10:09:42 -07001443 }
1444
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001445 /**
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001446 * Add a widget to the workspace.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001447 *
Romain Guy5bbc91b2010-08-18 11:38:46 -07001448 * @param appWidgetId The app widget id
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001449 */
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001450 @Thunk
1451 void completeAddAppWidget(int appWidgetId, ItemInfo itemInfo,
Adam Cohen59400422014-03-05 18:07:04 -08001452 AppWidgetHostView hostView, LauncherAppWidgetProviderInfo appWidgetInfo) {
1453
Adam Cohened66b2b2012-01-23 17:28:51 -08001454 if (appWidgetInfo == null) {
fbaron30d9e3f2023-08-03 17:03:59 -07001455 appWidgetInfo = mAppWidgetManager.getLauncherAppWidgetInfo(appWidgetId,
1456 itemInfo.getTargetComponent());
Adam Cohened66b2b2012-01-23 17:28:51 -08001457 }
Romain Guycbb89e42009-06-08 15:52:54 -07001458
Yogisha Dixit0b15c7e2021-05-10 12:01:58 +01001459 if (hostView == null) {
1460 // Perform actual inflation because we're live
Sihua Ma0593a0d2022-10-03 16:01:48 -07001461 hostView = mAppWidgetHolder.createView(this, appWidgetId, appWidgetInfo);
Yogisha Dixit0b15c7e2021-05-10 12:01:58 +01001462 }
1463
Adam Cohen59400422014-03-05 18:07:04 -08001464 LauncherAppWidgetInfo launcherInfo;
Yogisha Dixit0b15c7e2021-05-10 12:01:58 +01001465 launcherInfo =
1466 new LauncherAppWidgetInfo(
1467 appWidgetId, appWidgetInfo.provider, appWidgetInfo, hostView);
Sunny Goyal2100c782016-08-22 16:00:03 -07001468 launcherInfo.spanX = itemInfo.spanX;
1469 launcherInfo.spanY = itemInfo.spanY;
1470 launcherInfo.minSpanX = itemInfo.minSpanX;
1471 launcherInfo.minSpanY = itemInfo.minSpanY;
Sunny Goyal952e63d2017-08-16 04:59:08 -07001472 launcherInfo.user = appWidgetInfo.getProfile();
Yogisha Dixit658c5da2021-05-24 23:23:15 +01001473 if (itemInfo instanceof PendingAddWidgetInfo) {
1474 launcherInfo.sourceContainer = ((PendingAddWidgetInfo) itemInfo).sourceContainer;
1475 } else if (itemInfo instanceof PendingRequestArgs) {
1476 launcherInfo.sourceContainer =
1477 ((PendingRequestArgs) itemInfo).getWidgetSourceContainer();
1478 }
Sunny Goyal669b71f2023-01-27 14:37:07 -08001479 CellPos presenterPos = getCellPosMapper().mapModelToPresenter(itemInfo);
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001480 getModelWriter().addItemToDatabase(launcherInfo,
Sunny Goyal669b71f2023-01-27 14:37:07 -08001481 itemInfo.container, presenterPos.screenId, presenterPos.cellX, presenterPos.cellY);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001482
Sunny Goyal2100c782016-08-22 16:00:03 -07001483 hostView.setVisibility(View.VISIBLE);
Sunny Goyald5462aa2016-11-22 16:52:39 +05301484 prepareAppWidget(hostView, launcherInfo);
1485 mWorkspace.addInScreen(hostView, launcherInfo);
Pinyao Tingc9074272019-11-11 11:51:44 -08001486 announceForAccessibility(R.string.item_added_to_workspace);
Yogisha Dixit037a5362021-03-22 14:13:03 +00001487
1488 // Show the widget resize frame.
1489 if (hostView instanceof LauncherAppWidgetHostView) {
1490 final LauncherAppWidgetHostView launcherHostView = (LauncherAppWidgetHostView) hostView;
Sunny Goyal669b71f2023-01-27 14:37:07 -08001491 CellLayout cellLayout = getCellLayout(launcherInfo.container, presenterPos.screenId);
Yogisha Dixit037a5362021-03-22 14:13:03 +00001492 if (mStateManager.getState() == NORMAL) {
Yogisha Dixit7b1d25b2021-10-14 13:06:40 +01001493 AppWidgetResizeFrame.showForWidget(launcherHostView, cellLayout);
Yogisha Dixit037a5362021-03-22 14:13:03 +00001494 } else {
1495 mStateManager.addStateListener(new StateManager.StateListener<LauncherState>() {
1496 @Override
1497 public void onStateTransitionComplete(LauncherState finalState) {
Charlie Anderson438d4052023-04-25 14:38:57 -04001498 if ((mPrevLauncherState == SPRING_LOADED || mPrevLauncherState == EDIT_MODE)
1499 && finalState == NORMAL) {
Yogisha Dixit037a5362021-03-22 14:13:03 +00001500 AppWidgetResizeFrame.showForWidget(launcherHostView, cellLayout);
1501 mStateManager.removeStateListener(this);
1502 }
1503 }
1504 });
1505 }
1506 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001507 }
Romain Guycbb89e42009-06-08 15:52:54 -07001508
Sunny Goyald5462aa2016-11-22 16:52:39 +05301509 private void prepareAppWidget(AppWidgetHostView hostView, LauncherAppWidgetInfo item) {
Sunny Goyal87af0fd2016-05-16 14:56:02 -07001510 hostView.setTag(item);
1511 item.onBindAppWidget(this, hostView);
Sunny Goyal87af0fd2016-05-16 14:56:02 -07001512 hostView.setFocusable(true);
1513 hostView.setOnFocusChangeListener(mFocusHandler);
Sunny Goyal25c2e3e2015-10-28 23:28:21 -07001514 }
1515
Sunny Goyala992ac92023-01-10 17:50:32 -08001516 private final ScreenOnListener mScreenOnListener = this::onScreenOnChanged;
Adam Cohended9f8d2010-11-03 13:25:16 -07001517
Sunny Goyal9c2b9602020-01-07 13:07:55 -08001518 private void updateNotificationDots(Predicate<PackageUserKey> updatedDots) {
Tony Wickhamf34bee82018-12-03 18:11:39 -08001519 mWorkspace.updateNotificationDots(updatedDots);
1520 mAppsView.getAppsStore().updateNotificationDots(updatedDots);
Tony Wickham010d2552017-01-20 08:15:28 -08001521 }
1522
Adam Cohended9f8d2010-11-03 13:25:16 -07001523 @Override
1524 public void onAttachedToWindow() {
1525 super.onAttachedToWindow();
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001526 mOverlayManager.onAttachedToWindow();
Adam Cohended9f8d2010-11-03 13:25:16 -07001527 }
1528
1529 @Override
1530 public void onDetachedFromWindow() {
1531 super.onDetachedFromWindow();
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001532 mOverlayManager.onDetachedFromWindow();
1533 closeContextMenu();
Adam Cohended9f8d2010-11-03 13:25:16 -07001534 }
1535
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -07001536 @Override
1537 public Object onRetainNonConfigurationInstance() {
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08001538 NonConfigInstance instance = new NonConfigInstance();
1539 instance.config = new Configuration(mOldConfig);
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08001540 return instance;
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -07001541 }
1542
Sihua Ma0593a0d2022-10-03 16:01:48 -07001543 protected LauncherWidgetHolder createAppWidgetHolder() {
Sihua Ma1db8bc22022-11-08 17:13:13 -08001544 return LauncherWidgetHolder.HolderFactory.newFactory(this).newInstance(
1545 this, appWidgetId -> getWorkspace().removeWidget(appWidgetId));
Cyrus Boadway0d309db2021-04-14 12:29:14 +00001546 }
1547
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001548 @Override
1549 protected void onNewIntent(Intent intent) {
Brian Isganitisfdd044e2023-03-02 19:45:23 +00001550 if (Utilities.isRunningInTestHarness()) {
vadimtbaf5fbb2019-12-16 18:56:09 -08001551 Log.d(TestProtocol.PERMANENT_DIAG_TAG, "Launcher.onNewIntent: " + intent);
1552 }
Sunny Goyal67736672023-06-02 13:35:19 +00001553 TraceHelper.INSTANCE.beginSection(ON_NEW_INTENT_EVT);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001554 super.onNewIntent(intent);
1555
Sunny Goyalf4aceab2017-12-06 16:16:31 -08001556 boolean alreadyOnHome = hasWindowFocus() && ((intent.getFlags() &
Winson15f8b172015-08-19 11:02:39 -07001557 Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT)
1558 != Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT);
Sunny Goyal85313732016-09-28 12:00:07 -07001559
1560 // Check this condition before handling isActionMain, as this will get reset.
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001561 boolean shouldMoveToDefaultScreen = alreadyOnHome && isInState(NORMAL)
Sunny Goyalf9403d92017-10-18 10:55:56 -07001562 && AbstractFloatingView.getTopOpenView(this) == null;
Winson15f8b172015-08-19 11:02:39 -07001563 boolean isActionMain = Intent.ACTION_MAIN.equals(intent.getAction());
Winson Chung1c2d5222021-06-08 11:50:13 -07001564 boolean internalStateHandled = ACTIVITY_TRACKER.handleNewIntent(this);
kholoud mohamedceec31b2022-02-03 15:44:25 +00001565
Winson15f8b172015-08-19 11:02:39 -07001566 if (isActionMain) {
Sunny Goyald3864fa2017-11-14 15:06:36 -08001567 if (!internalStateHandled) {
Sunny Goyald3864fa2017-11-14 15:06:36 -08001568 // In all these cases, only animate if we're already on home
Schneider Victor-tulias3913e292023-07-21 15:24:57 -07001569 AbstractFloatingView.closeAllOpenViewsExcept(
1570 this, isStarted(), AbstractFloatingView.TYPE_LISTENER);
Jon Mirandafeba90f2016-10-06 10:53:29 -07001571
Sunny Goyala2467272018-03-16 14:53:05 -07001572 if (!isInState(NORMAL)) {
1573 // Only change state, if not already the same. This prevents cancelling any
1574 // animations running as part of resume
Sunny Goyalfee1b252020-12-14 12:30:38 -08001575 mStateManager.goToState(NORMAL, mStateManager.shouldAnimateStateChange());
Sunny Goyala2467272018-03-16 14:53:05 -07001576 }
Sunny Goyald3864fa2017-11-14 15:06:36 -08001577
1578 // Reset the apps view
Sunny Goyal5d1873a2018-05-08 11:10:44 -07001579 if (!alreadyOnHome) {
Sunny Goyal7185dd62018-03-14 17:51:49 -07001580 mAppsView.reset(isStarted() /* animate */);
Sunny Goyald3864fa2017-11-14 15:06:36 -08001581 }
1582
Sunny Goyalaad33592018-08-07 17:20:35 -07001583 if (shouldMoveToDefaultScreen && !mWorkspace.isHandlingTouch()) {
Sunny Goyald3864fa2017-11-14 15:06:36 -08001584 mWorkspace.post(mWorkspace::moveToDefaultScreen);
1585 }
1586 }
Adam Cohen6fecd412013-10-02 17:41:50 -07001587
Adam Cohen9211d422014-10-07 18:14:53 -07001588 if (mLauncherCallbacks != null) {
Sunny Goyal85462132018-04-24 11:39:37 -07001589 mLauncherCallbacks.onHomeIntent(internalStateHandled);
Adam Cohen9211d422014-10-07 18:14:53 -07001590 }
Vinit Nayakf6c2e872023-07-07 13:37:24 -07001591 if (FeatureFlags.ENABLE_SPLIT_FROM_WORKSPACE_TO_WORKSPACE.get()) {
1592 handleSplitAnimationGoingToHome();
1593 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001594 mOverlayManager.hideOverlay(isStarted() && !isForceInvisible());
Sunny Goyal30ac97d2020-06-24 23:47:46 -07001595 handleGestureContract(intent);
Sunny Goyal512a2c12020-04-08 12:52:45 -07001596 } else if (Intent.ACTION_ALL_APPS.equals(intent.getAction())) {
Winson Chungdd15ace2020-08-04 15:52:01 -07001597 showAllAppsFromIntent(alreadyOnHome);
Tracy Zhoucb93ec52023-03-31 22:51:17 -07001598 } else if (INTENT_ACTION_ALL_APPS_TOGGLE.equals(intent.getAction())) {
1599 toggleAllAppsFromIntent(alreadyOnHome);
kholoud mohamedceec31b2022-02-03 15:44:25 +00001600 } else if (Intent.ACTION_SHOW_WORK_APPS.equals(intent.getAction())) {
1601 showAllAppsWorkTabFromIntent(alreadyOnHome);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001602 }
Winson15f8b172015-08-19 11:02:39 -07001603
Sunny Goyal67736672023-06-02 13:35:19 +00001604 TraceHelper.INSTANCE.endSection();
Adam Coppa120b8e2013-11-12 16:26:04 +00001605 }
1606
Vinit Nayakf6c2e872023-07-07 13:37:24 -07001607 /** Handle animating away split placeholder view when user taps on home button */
1608 protected void handleSplitAnimationGoingToHome() {
1609 // Overridden
1610 }
1611
Tracy Zhoucb93ec52023-03-31 22:51:17 -07001612 protected void toggleAllAppsFromIntent(boolean alreadyOnHome) {
1613 if (getStateManager().isInStableState(ALL_APPS)) {
1614 getStateManager().goToState(NORMAL, alreadyOnHome);
1615 } else {
Holly Sund9d70ea2023-09-05 13:14:22 -07001616 AbstractFloatingView.closeAllOpenViews(this);
1617 getStateManager().goToState(ALL_APPS, true /* animated */,
1618 new AnimationSuccessListener() {
1619 @Override
1620 public void onAnimationSuccess(Animator animator) {
1621 if (mAppsView.getSearchUiManager().getEditText() != null) {
1622 mAppsView.getSearchUiManager().getEditText().requestFocus();
1623 }
1624 }
1625 });
Tracy Zhoucb93ec52023-03-31 22:51:17 -07001626 }
1627 }
1628
Winson Chungdd15ace2020-08-04 15:52:01 -07001629 protected void showAllAppsFromIntent(boolean alreadyOnHome) {
1630 AbstractFloatingView.closeAllOpenViews(this);
1631 getStateManager().goToState(ALL_APPS, alreadyOnHome);
1632 }
1633
kholoud mohamedceec31b2022-02-03 15:44:25 +00001634 private void showAllAppsWorkTabFromIntent(boolean alreadyOnHome) {
1635 showAllAppsFromIntent(alreadyOnHome);
Sunny Goyal34c499d2023-01-24 12:43:18 -08001636 mAppsView.switchToTab(ActivityAllAppsContainerView.AdapterHolder.WORK);
kholoud mohamedceec31b2022-02-03 15:44:25 +00001637 }
1638
Sunny Goyaldeb91c42020-03-24 02:17:59 -07001639 /**
Sunny Goyal30ac97d2020-06-24 23:47:46 -07001640 * Handles gesture nav contract
1641 */
1642 protected void handleGestureContract(Intent intent) {
1643 GestureNavContract gnc = GestureNavContract.fromIntent(intent);
1644 if (gnc != null) {
1645 AbstractFloatingView.closeOpenViews(this, false, TYPE_ICON_SURFACE);
1646 FloatingSurfaceView.show(this, gnc);
1647 }
1648 }
1649
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001650 @Override
Adam Cohen1462de32012-07-24 22:34:36 -07001651 public void onRestoreInstanceState(Bundle state) {
1652 super.onRestoreInstanceState(state);
Andras Kloczl55edfe52021-05-14 12:21:30 +02001653 if (mSynchronouslyBoundPages != null) {
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07001654 mSynchronouslyBoundPages.forEach(screenId -> {
1655 int pageIndex = mWorkspace.getPageIndexForScreenId(screenId);
1656 if (pageIndex != PagedView.INVALID_PAGE) {
1657 mWorkspace.restoreInstanceStateForChild(pageIndex);
1658 }
1659 });
Andras Kloczl55edfe52021-05-14 12:21:30 +02001660 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001661 }
1662
1663 @Override
1664 protected void onSaveInstanceState(Bundle outState) {
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07001665 outState.putIntArray(RUNTIME_STATE_CURRENT_SCREEN_IDS,
1666 mWorkspace.getCurrentPageScreenIds().getArray().toArray());
Sunny Goyalea609262017-10-25 15:47:38 -07001667 outState.putInt(RUNTIME_STATE, mStateManager.getState().ordinal);
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001668
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001669 AbstractFloatingView widgets = AbstractFloatingView
1670 .getOpenView(this, AbstractFloatingView.TYPE_WIDGETS_FULL_SHEET);
1671 if (widgets != null) {
1672 SparseArray<Parcelable> widgetsState = new SparseArray<>();
1673 widgets.saveHierarchyState(widgetsState);
1674 outState.putSparseParcelableArray(RUNTIME_STATE_WIDGET_PANEL, widgetsState);
1675 } else {
1676 outState.remove(RUNTIME_STATE_WIDGET_PANEL);
1677 }
1678
Federico Baron8bf1bca2022-09-27 16:19:11 -07001679 // We close any open folders and shortcut containers that are not safe for rebind,
1680 // and we need to make sure this state is reflected.
1681 AbstractFloatingView.closeAllOpenViewsExcept(
1682 this, isStarted() && !isForceInvisible(), TYPE_REBIND_SAFE);
Pinyao Tinga74b63a2019-07-17 23:26:06 -07001683 finishAutoCancelActionMode();
Tony Wickham49c8d292016-07-01 11:44:34 -07001684
Sunny Goyal2100c782016-08-22 16:00:03 -07001685 if (mPendingRequestArgs != null) {
1686 outState.putParcelable(RUNTIME_STATE_PENDING_REQUEST_ARGS, mPendingRequestArgs);
1687 }
Sunny Goyaldedda052019-05-14 15:23:48 -07001688 outState.putInt(RUNTIME_STATE_PENDING_REQUEST_CODE, mPendingActivityRequestCode);
1689
Sunny Goyal2100c782016-08-22 16:00:03 -07001690 if (mPendingActivityResult != null) {
1691 outState.putParcelable(RUNTIME_STATE_PENDING_ACTIVITY_RESULT, mPendingActivityResult);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001692 }
1693
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001694 super.onSaveInstanceState(outState);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001695 mOverlayManager.onActivitySaveInstanceState(this, outState);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001696 }
1697
1698 @Override
1699 public void onDestroy() {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001700 super.onDestroy();
Sunny Goyale84c5b82019-09-26 17:05:31 -07001701 ACTIVITY_TRACKER.onActivityDestroyed(this);
Romain Guycbb89e42009-06-08 15:52:54 -07001702
Sunny Goyala992ac92023-01-10 17:50:32 -08001703 ScreenOnTracker.INSTANCE.get(this).removeListener(mScreenOnListener);
Sunny Goyalaaf7d1d2016-05-17 13:38:54 -07001704 mWorkspace.removeFolderListeners();
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001705 PluginManagerWrapper.INSTANCE.get(this).removePluginListener(this);
Winson Chunge7a03942011-08-05 15:05:12 -07001706
Sunny Goyala7a5bf32020-01-05 15:35:29 +05301707 mModel.removeCallbacks(this);
Sunny Goyal623eddd2018-03-02 12:24:41 -08001708 mRotationHelper.destroy();
Sunny Goyal745bad92016-05-02 10:54:12 -07001709
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001710 try {
Sihua Ma0593a0d2022-10-03 16:01:48 -07001711 mAppWidgetHolder.stopListening();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001712 } catch (NullPointerException ex) {
Joe Onoratoa30ce8e2009-11-11 08:16:49 -08001713 Log.w(TAG, "problem while stopping AppWidgetHost during Launcher destruction", ex);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001714 }
Sihua Maaa2b8722022-10-25 15:17:58 -07001715 mAppWidgetHolder.destroy();
Patrick Dubroy2313eff2011-01-11 20:01:31 -08001716
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001717 TextKeyListener.getInstance().release();
Tony2917a8b2017-07-31 23:29:42 -07001718 clearPendingBinds();
Hyunyoung Song31971a32019-01-27 12:31:12 -08001719 LauncherAppState.getIDP(this).removeOnChangeListener(this);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001720
1721 mOverlayManager.onActivityDestroyed(this);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001722 }
1723
Sunny Goyalae502842016-06-17 08:43:56 -07001724 public LauncherAccessibilityDelegate getAccessibilityDelegate() {
1725 return mAccessibilityDelegate;
1726 }
1727
Adam Cohena9cf38f2011-05-02 15:36:58 -07001728 public DragController getDragController() {
1729 return mDragController;
1730 }
1731
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001732 @Override
Andrew Cole44898c32023-04-05 13:49:32 -07001733 public DropTargetHandler getDropTargetHandler() {
1734 return new DropTargetHandler(this);
1735 }
1736
1737 @Override
Sunny Goyal0eca4e22016-07-20 11:43:06 -07001738 public void startActivityForResult(Intent intent, int requestCode, Bundle options) {
Sunny Goyaldedda052019-05-14 15:23:48 -07001739 if (requestCode != -1) {
1740 mPendingActivityRequestCode = requestCode;
1741 }
Sunny Goyal210e1742019-10-17 12:05:38 -07001742 super.startActivityForResult(intent, requestCode, options);
Adam Cohen173f7112015-03-27 15:14:00 -07001743 }
1744
1745 @Override
Sunny Goyaldedda052019-05-14 15:23:48 -07001746 public void startIntentSenderForResult(IntentSender intent, int requestCode,
Adam Cohen173f7112015-03-27 15:14:00 -07001747 Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags, Bundle options) {
Sunny Goyaldedda052019-05-14 15:23:48 -07001748 if (requestCode != -1) {
1749 mPendingActivityRequestCode = requestCode;
1750 }
Sunny Goyal210e1742019-10-17 12:05:38 -07001751 try {
1752 super.startIntentSenderForResult(intent, requestCode,
1753 fillInIntent, flagsMask, flagsValues, extraFlags, options);
1754 } catch (IntentSender.SendIntentException e) {
1755 throw new ActivityNotFoundException();
Adam Cohen173f7112015-03-27 15:14:00 -07001756 }
1757 }
1758
Winson Chung70d72102011-08-12 11:24:35 -07001759 /**
1760 * Indicates that we want global search for this activity by setting the globalSearch
1761 * argument for {@link #startSearch} to true.
1762 */
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001763 @Override
Romain Guycbb89e42009-06-08 15:52:54 -07001764 public void startSearch(String initialQuery, boolean selectInitialQuery,
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001765 Bundle appSearchData, boolean globalSearch) {
1766 if (appSearchData == null) {
1767 appSearchData = new Bundle();
Bjorn Bringert32b12d22013-06-06 13:00:41 +01001768 appSearchData.putString("source", "launcher-search");
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001769 }
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07001770
Sunny Goyal6f28e712016-09-13 14:19:29 -07001771 if (mLauncherCallbacks == null ||
1772 !mLauncherCallbacks.startSearch(initialQuery, selectInitialQuery, appSearchData)) {
1773 // Starting search from the callbacks failed. Start the default global search.
Sunny Goyalf4aceab2017-12-06 16:16:31 -08001774 super.startSearch(initialQuery, selectInitialQuery, appSearchData, true);
Ian Parkinson047036e2014-09-01 15:40:53 +01001775 }
Winson Chungcd99cd32015-04-29 11:03:24 -07001776
1777 // We need to show the workspace after starting the search
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001778 mStateManager.goToState(NORMAL);
Bjorn Bringertc459e522013-06-07 19:36:01 +01001779 }
1780
Sunny Goyal2100c782016-08-22 16:00:03 -07001781 void addAppWidgetFromDropImpl(int appWidgetId, ItemInfo info, AppWidgetHostView boundWidget,
Sunny Goyal04a324a2017-01-20 21:08:59 -08001782 WidgetAddFlowHandler addFlowHandler) {
Tony Wickhama0628cc2015-10-14 15:23:04 -07001783 if (LOGD) {
1784 Log.d(TAG, "Adding widget from drop");
1785 }
Sunny Goyal04a324a2017-01-20 21:08:59 -08001786 addAppWidgetImpl(appWidgetId, info, boundWidget, addFlowHandler, 0);
Adam Cohenad4e15c2013-10-17 16:21:35 -07001787 }
1788
Sunny Goyal2100c782016-08-22 16:00:03 -07001789 void addAppWidgetImpl(int appWidgetId, ItemInfo info,
Sunny Goyal04a324a2017-01-20 21:08:59 -08001790 AppWidgetHostView boundWidget, WidgetAddFlowHandler addFlowHandler, int delay) {
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001791 if (!addFlowHandler.startConfigActivity(this, appWidgetId, info,
1792 REQUEST_CREATE_APPWIDGET)) {
Sunny Goyal04a324a2017-01-20 21:08:59 -08001793 // If the configuration flow was not started, add the widget
Michael Jurkaaf442092010-06-10 17:01:57 -07001794
Charlie Anderson438d4052023-04-25 14:38:57 -04001795 // Exit spring loaded mode if necessary after adding the widget
1796 Runnable onComplete = MULTI_SELECT_EDIT_MODE.get() ? null
1797 : () -> mStateManager.goToState(NORMAL, SPRING_LOADED_EXIT_DELAY);
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001798 completeAddAppWidget(appWidgetId, info, boundWidget,
1799 addFlowHandler.getProviderInfo(this));
Sunny Goyal6e379fc2020-03-19 16:08:14 -07001800 mWorkspace.removeExtraEmptyScreenDelayed(delay, false, onComplete);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001801 }
1802 }
Romain Guycbb89e42009-06-08 15:52:54 -07001803
Sunny Goyalefb7e842018-10-04 15:11:00 -07001804 public void addPendingItem(PendingAddItemInfo info, int container, int screenId,
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08001805 int[] cell, int spanX, int spanY) {
Sunny Goyal669b71f2023-01-27 14:37:07 -08001806 if (cell == null) {
1807 CellPos modelPos = getCellPosMapper().mapPresenterToModel(0, 0, screenId, container);
1808 info.screenId = modelPos.screenId;
1809 } else {
1810 CellPos modelPos = getCellPosMapper().mapPresenterToModel(
1811 cell[0], cell[1], screenId, container);
1812 info.screenId = modelPos.screenId;
1813 info.cellX = modelPos.cellX;
1814 info.cellY = modelPos.cellY;
Sunny Goyal2100c782016-08-22 16:00:03 -07001815 }
Sunny Goyal669b71f2023-01-27 14:37:07 -08001816 info.container = container;
Sunny Goyal2100c782016-08-22 16:00:03 -07001817 info.spanX = spanX;
1818 info.spanY = spanY;
1819
Holly Sun35b99602023-06-28 15:14:02 -07001820 if (info instanceof PendingAddWidgetInfo) {
1821 addAppWidgetFromDrop((PendingAddWidgetInfo) info);
1822 } else { // info can only be PendingAddShortcutInfo
1823 processShortcutFromDrop((PendingAddShortcutInfo) info);
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001824 }
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08001825 }
1826
Adam Cohenfbba09b2011-07-18 21:43:05 -07001827 /**
1828 * Process a shortcut drop.
Adam Cohenfbba09b2011-07-18 21:43:05 -07001829 */
Sunny Goyal782f0c92017-01-19 10:27:54 -08001830 private void processShortcutFromDrop(PendingAddShortcutInfo info) {
Sunny Goyalfb5096d2016-09-08 14:32:06 -07001831 Intent intent = new Intent(Intent.ACTION_CREATE_SHORTCUT).setComponent(info.componentName);
1832 setWaitingForResult(PendingRequestArgs.forIntent(REQUEST_CREATE_SHORTCUT, intent, info));
vadimtcf275c12020-04-15 12:43:01 -07001833 TestLogging.recordEvent(TestProtocol.SEQUENCE_MAIN, "start: processShortcutFromDrop");
Sunny Goyal239d6e92023-02-07 13:40:11 -08001834 if (!info.getActivityInfo(this).startConfigActivity(this, REQUEST_CREATE_SHORTCUT)) {
Sunny Goyal782f0c92017-01-19 10:27:54 -08001835 handleActivityResult(REQUEST_CREATE_SHORTCUT, RESULT_CANCELED, null);
1836 }
Michael Jurka0280c3b2010-09-17 15:00:07 -07001837 }
1838
Adam Cohenfbba09b2011-07-18 21:43:05 -07001839 /**
1840 * Process a widget drop.
Adam Cohenfbba09b2011-07-18 21:43:05 -07001841 */
Sunny Goyal2100c782016-08-22 16:00:03 -07001842 private void addAppWidgetFromDrop(PendingAddWidgetInfo info) {
Adam Cohened66b2b2012-01-23 17:28:51 -08001843 AppWidgetHostView hostView = info.boundWidget;
Sunny Goyal952e63d2017-08-16 04:59:08 -07001844 final int appWidgetId;
Sunny Goyal8a0dc382017-01-25 11:30:06 -08001845 WidgetAddFlowHandler addFlowHandler = info.getHandler();
Adam Cohened66b2b2012-01-23 17:28:51 -08001846 if (hostView != null) {
Tony Wickhama0628cc2015-10-14 15:23:04 -07001847 // In the case where we've prebound the widget, we remove it from the DragLayer
1848 if (LOGD) {
1849 Log.d(TAG, "Removing widget view from drag layer and setting boundWidget to null");
1850 }
1851 getDragLayer().removeView(hostView);
1852
Adam Cohened66b2b2012-01-23 17:28:51 -08001853 appWidgetId = hostView.getAppWidgetId();
Sunny Goyal04a324a2017-01-20 21:08:59 -08001854 addAppWidgetFromDropImpl(appWidgetId, info, hostView, addFlowHandler);
Sunny Goyal5b9ebca2015-06-01 18:37:32 -07001855
1856 // Clear the boundWidget so that it doesn't get destroyed.
1857 info.boundWidget = null;
Adam Cohened66b2b2012-01-23 17:28:51 -08001858 } else {
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001859 // In this case, we either need to start an activity to get permission to bind
1860 // the widget, or we need to start an activity to configure the widget, or both.
Pinyao Tingc7a6c292019-08-26 14:36:02 -07001861 if (info.itemType == LauncherSettings.Favorites.ITEM_TYPE_CUSTOM_APPWIDGET) {
fbaron30d9e3f2023-08-03 17:03:59 -07001862 appWidgetId = CustomWidgetManager.INSTANCE.get(this)
1863 .allocateCustomAppWidgetId(info.componentName);
Sunny Goyal952e63d2017-08-16 04:59:08 -07001864 } else {
Sihua Ma0593a0d2022-10-03 16:01:48 -07001865 appWidgetId = getAppWidgetHolder().allocateAppWidgetId();
Sunny Goyal952e63d2017-08-16 04:59:08 -07001866 }
Adam Cohendd70d662012-10-04 16:53:44 -07001867 Bundle options = info.bindOptions;
1868
Sunny Goyalffe83f12014-08-14 17:39:34 -07001869 boolean success = mAppWidgetManager.bindAppWidgetIdIfAllowed(
1870 appWidgetId, info.info, options);
Adam Cohendd70d662012-10-04 16:53:44 -07001871 if (success) {
Sunny Goyal04a324a2017-01-20 21:08:59 -08001872 addAppWidgetFromDropImpl(appWidgetId, info, null, addFlowHandler);
Michael Jurka8b805b12012-04-18 14:23:14 -07001873 } else {
Sunny Goyal04a324a2017-01-20 21:08:59 -08001874 addFlowHandler.startBindFlow(this, appWidgetId, info, REQUEST_BIND_APPWIDGET);
Michael Jurka8b805b12012-04-18 14:23:14 -07001875 }
Adam Cohened66b2b2012-01-23 17:28:51 -08001876 }
Adam Cohenfbba09b2011-07-18 21:43:05 -07001877 }
1878
Samuel Fufa746d4202020-02-02 18:55:44 -08001879 /**
1880 * Creates and adds new folder to CellLayout
1881 */
Samuel Fufa28c3e452020-02-08 16:07:16 -08001882 public FolderIcon addFolder(CellLayout layout, int container, final int screenId, int cellX,
1883 int cellY) {
Michael Jurkac9d95c52011-08-29 14:03:34 -07001884 final FolderInfo folderInfo = new FolderInfo();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001885
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001886 // Update the model
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001887 getModelWriter().addItemToDatabase(folderInfo, container, screenId, cellX, cellY);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001888
1889 // Create the view
Samuel Fufa746d4202020-02-02 18:55:44 -08001890 FolderIcon newFolder = FolderIcon.inflateFolderAndIcon(R.layout.folder_icon, this, layout,
1891 folderInfo);
Sunny Goyald5462aa2016-11-22 16:52:39 +05301892 mWorkspace.addInScreen(newFolder, folderInfo);
Winson Chung5f8afe62013-08-12 16:19:28 -07001893 // Force measure the new folder icon
1894 CellLayout parent = mWorkspace.getParentCellLayoutForView(newFolder);
1895 parent.getShortcutsAndWidgets().measureChild(newFolder);
Adam Cohendf035382011-04-11 17:22:04 -07001896 return newFolder;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001897 }
Romain Guycbb89e42009-06-08 15:52:54 -07001898
Tony Wickham1906cc32021-02-11 11:55:24 -08001899 @Override
1900 public Rect getFolderBoundingBox() {
1901 // We need to bound the folder to the currently visible workspace area
Andras Kloczl3a4ba0b2021-03-29 18:47:14 +02001902 return getWorkspace().getPageAreaRelativeToDragLayer();
Tony Wickham1906cc32021-02-11 11:55:24 -08001903 }
1904
1905 @Override
1906 public void updateOpenFolderPosition(int[] inOutPosition, Rect bounds, int width, int height) {
1907 int left = inOutPosition[0];
1908 int top = inOutPosition[1];
1909 DeviceProfile grid = getDeviceProfile();
1910 int distFromEdgeOfScreen = getWorkspace().getPaddingLeft();
1911 if (grid.isPhone && (grid.availableWidthPx - width) < 4 * distFromEdgeOfScreen) {
1912 // Center the folder if it is very close to being centered anyway, by virtue of
1913 // filling the majority of the viewport. ie. remove it from the uncanny valley
1914 // of centeredness.
1915 left = (grid.availableWidthPx - width) / 2;
1916 } else if (width >= bounds.width()) {
1917 // If the folder doesn't fit within the bounds, center it about the desired bounds
1918 left = bounds.left + (bounds.width() - width) / 2;
1919 }
1920 if (height >= bounds.height()) {
1921 // Folder height is greater than page height, center on page
1922 top = bounds.top + (bounds.height() - height) / 2;
1923 } else {
1924 // Folder height is less than page height, so bound it to the absolute open folder
1925 // bounds if necessary
1926 Rect folderBounds = grid.getAbsoluteOpenFolderBounds();
1927 left = Math.max(folderBounds.left, Math.min(left, folderBounds.right - width));
1928 top = Math.max(folderBounds.top, Math.min(top, folderBounds.bottom - height));
1929 }
1930 inOutPosition[0] = left;
1931 inOutPosition[1] = top;
1932 }
1933
Winsonc0b52fe2015-09-09 16:38:15 -07001934 /**
Winsonfa56b3f2015-09-14 12:01:13 -07001935 * Unbinds the view for the specified item, and removes the item and all its children.
1936 *
1937 * @param v the view being removed.
Winsonfa56b3f2015-09-14 12:01:13 -07001938 * @param itemInfo the {@link ItemInfo} for this view.
1939 * @param deleteFromDb whether or not to delete this item from the db.
Winsonc0b52fe2015-09-09 16:38:15 -07001940 */
Tony Wickhambfbf7f92016-05-19 11:19:39 -07001941 public boolean removeItem(View v, final ItemInfo itemInfo, boolean deleteFromDb) {
Pinyao Ting6a41d562022-05-10 23:47:36 +00001942 return removeItem(v, itemInfo, deleteFromDb, null);
1943 }
1944
1945 /**
1946 * Unbinds the view for the specified item, and removes the item and all its children.
1947 *
1948 * @param v the view being removed.
1949 * @param itemInfo the {@link ItemInfo} for this view.
1950 * @param deleteFromDb whether or not to delete this item from the db.
1951 * @param reason the resaon for removal.
1952 */
1953 public boolean removeItem(View v, final ItemInfo itemInfo, boolean deleteFromDb,
1954 @Nullable final String reason) {
Sunny Goyal95899162019-03-27 16:03:06 -07001955 if (itemInfo instanceof WorkspaceItemInfo) {
Winsonfa56b3f2015-09-14 12:01:13 -07001956 // Remove the shortcut from the folder before removing it from launcher
Sunny Goyal44c06432016-04-02 10:56:02 -07001957 View folderIcon = mWorkspace.getHomescreenIconByItemId(itemInfo.container);
1958 if (folderIcon instanceof FolderIcon) {
Sunny Goyal95899162019-03-27 16:03:06 -07001959 ((FolderInfo) folderIcon.getTag()).remove((WorkspaceItemInfo) itemInfo, true);
Winsonfa56b3f2015-09-14 12:01:13 -07001960 } else {
1961 mWorkspace.removeWorkspaceItem(v);
1962 }
Winsonc0b52fe2015-09-09 16:38:15 -07001963 if (deleteFromDb) {
Pinyao Ting6a41d562022-05-10 23:47:36 +00001964 getModelWriter().deleteItemFromDatabase(itemInfo, reason);
Winsonc0b52fe2015-09-09 16:38:15 -07001965 }
1966 } else if (itemInfo instanceof FolderInfo) {
1967 final FolderInfo folderInfo = (FolderInfo) itemInfo;
Sunny Goyalaaf7d1d2016-05-17 13:38:54 -07001968 if (v instanceof FolderIcon) {
1969 ((FolderIcon) v).removeListeners();
1970 }
Winsonc0b52fe2015-09-09 16:38:15 -07001971 mWorkspace.removeWorkspaceItem(v);
1972 if (deleteFromDb) {
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001973 getModelWriter().deleteFolderAndContentsFromDatabase(folderInfo);
Winsonc0b52fe2015-09-09 16:38:15 -07001974 }
1975 } else if (itemInfo instanceof LauncherAppWidgetInfo) {
1976 final LauncherAppWidgetInfo widgetInfo = (LauncherAppWidgetInfo) itemInfo;
Winson44818e02015-10-02 11:25:46 -07001977 mWorkspace.removeWorkspaceItem(v);
Winsonc0b52fe2015-09-09 16:38:15 -07001978 if (deleteFromDb) {
Sihua Ma0593a0d2022-10-03 16:01:48 -07001979 getModelWriter().deleteWidgetInfo(widgetInfo, getAppWidgetHolder(), reason);
Winsonc0b52fe2015-09-09 16:38:15 -07001980 }
1981 } else {
1982 return false;
1983 }
1984 return true;
1985 }
1986
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001987 @Override
1988 public boolean dispatchKeyEvent(KeyEvent event) {
vadimt6b534ee2021-08-06 15:49:02 -07001989 TestLogging.recordKeyEvent(TestProtocol.SEQUENCE_MAIN, "Key event", event);
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08001990 return (event.getKeyCode() == KeyEvent.KEYCODE_HOME) || super.dispatchKeyEvent(event);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001991 }
1992
Joe Onorato88ec0992009-11-19 13:16:06 -08001993 @Override
vadimt9af34a72020-01-21 11:19:13 -08001994 public boolean dispatchTouchEvent(MotionEvent ev) {
Sunny Goyala306e592020-03-24 01:51:41 -07001995 switch (ev.getAction()) {
1996 case MotionEvent.ACTION_DOWN:
1997 mTouchInProgress = true;
1998 break;
1999 case MotionEvent.ACTION_UP:
Riddle Hsub30adcb2020-10-07 15:57:44 +08002000 mLastTouchUpTime = SystemClock.uptimeMillis();
Sunny Goyala306e592020-03-24 01:51:41 -07002001 // Follow through
2002 case MotionEvent.ACTION_CANCEL:
2003 mTouchInProgress = false;
2004 break;
Sunny Goyal9b180102020-03-11 10:02:29 -07002005 }
vadimtd633c9c2020-01-22 18:00:37 -08002006 TestLogging.recordMotionEvent(TestProtocol.SEQUENCE_MAIN, "Touch event", ev);
vadimt9af34a72020-01-21 11:19:13 -08002007 return super.dispatchTouchEvent(ev);
2008 }
2009
2010 @Override
Fengjiang Lib7860bd2023-03-15 10:50:50 -07002011 @TargetApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
Joe Onorato88ec0992009-11-19 13:16:06 -08002012 public void onBackPressed() {
Fengjiang Lib7860bd2023-03-15 10:50:50 -07002013 getOnBackAnimationCallback().onBackInvoked();
Joe Onorato88ec0992009-11-19 13:16:06 -08002014 }
2015
Sunny Goyal3f2637f2022-05-05 12:24:08 -07002016 protected void onStateBack() {
2017 mStateManager.getState().onBackPressed(this);
2018 }
2019
Sunny Goyala992ac92023-01-10 17:50:32 -08002020 protected void onScreenOnChanged(boolean isOn) {
Tracy Zhouf20a4bd2021-04-19 21:37:08 -07002021 // Reset AllApps to its initial state only if we are not in the middle of
2022 // processing a multi-step drop
Sunny Goyala992ac92023-01-10 17:50:32 -08002023 if (!isOn && mPendingRequestArgs == null) {
Tracy Zhouf20a4bd2021-04-19 21:37:08 -07002024 if (!isInState(NORMAL)) {
2025 onUiChangedWhileSleeping();
2026 }
2027 mStateManager.goToState(NORMAL);
2028 }
2029 }
2030
Hyunyoung Song46d07f72018-05-22 15:41:25 -07002031 @Override
Sunny Goyal4fdc9182023-05-12 12:08:53 -07002032 public RunnableList startActivitySafely(View v, Intent intent, ItemInfo item) {
Winson Chung0b70cd42019-06-17 22:34:33 -07002033 if (!hasBeenResumed()) {
Sunny Goyal4fdc9182023-05-12 12:08:53 -07002034 RunnableList result = new RunnableList();
Winson Chung0b70cd42019-06-17 22:34:33 -07002035 // Workaround an issue where the WM launch animation is clobbered when finishing the
2036 // recents animation into launcher. Defer launching the activity until Launcher is
2037 // next resumed.
Sunny Goyal4fdc9182023-05-12 12:08:53 -07002038 addOnResumeCallback(() -> {
2039 RunnableList actualResult = startActivitySafely(v, intent, item);
2040 if (actualResult != null) {
2041 actualResult.add(result::executeAllAndDestroy);
2042 } else {
2043 result.executeAllAndDestroy();
2044 }
2045 });
Winson Chungc9bf6d42019-10-04 15:33:18 -07002046 if (mOnDeferredActivityLaunchCallback != null) {
2047 mOnDeferredActivityLaunchCallback.run();
2048 mOnDeferredActivityLaunchCallback = null;
2049 }
Sunny Goyal4fdc9182023-05-12 12:08:53 -07002050 return result;
Winson Chung0b70cd42019-06-17 22:34:33 -07002051 }
2052
Sunny Goyal4fdc9182023-05-12 12:08:53 -07002053 RunnableList result = super.startActivitySafely(v, intent, item);
2054 if (result != null && v instanceof BubbleTextView) {
Sunny Goyal0b0847b2018-03-14 12:30:11 -07002055 // This is set to the view that launched the activity that navigated the user away
2056 // from launcher. Since there is no callback for when the activity has finished
2057 // launching, enable the press state and keep this reference to reset the press
2058 // state when we return to launcher.
2059 BubbleTextView btv = (BubbleTextView) v;
2060 btv.setStayPressed(true);
Sunny Goyal4fdc9182023-05-12 12:08:53 -07002061 result.add(() -> btv.setStayPressed(false));
Sunny Goyala7ce1662016-05-31 15:01:35 -07002062 }
Sunny Goyal4fdc9182023-05-12 12:08:53 -07002063 return result;
Michael Jurka86a720e2012-05-09 11:23:23 -07002064 }
2065
Winson Chung3d503fb2011-07-13 17:25:49 -07002066 boolean isHotseatLayout(View layout) {
Sunny Goyalc13403c2016-11-18 23:44:48 -08002067 // TODO: Remove this method
Sunny Goyal876e4622018-11-02 13:50:40 -07002068 return mHotseat != null && (layout == mHotseat);
Winson Chung3d503fb2011-07-13 17:25:49 -07002069 }
Romain Guy1fbc1c82009-11-09 20:43:08 -08002070
Michael Jurkae326f182011-11-21 14:05:46 -08002071 @Override
2072 public void onTrimMemory(int level) {
2073 super.onTrimMemory(level);
Adam Cohen3f9c9712014-10-31 11:48:25 -07002074 if (level >= ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN) {
2075 // The widget preview db can result in holding onto over
2076 // 3MB of memory for caching which isn't necessary.
2077 SQLiteDatabase.releaseMemory();
2078
Adam Cohenc8f4e1b2014-11-19 16:03:20 -08002079 // This clears all widget bitmaps from the widget tray
Hyunyoung Song3f471442015-04-08 19:01:34 -07002080 // TODO(hyunyoungs)
Michael Jurkae326f182011-11-21 14:05:46 -08002081 }
2082 }
2083
Michael Jurkad7c28052012-04-27 15:43:36 -07002084 @Override
2085 public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
alanv1d4fde62012-10-17 13:15:47 -07002086 final boolean result = super.dispatchPopulateAccessibilityEvent(event);
Michael Jurkad7c28052012-04-27 15:43:36 -07002087 final List<CharSequence> text = event.getText();
2088 text.clear();
alanv1d4fde62012-10-17 13:15:47 -07002089 // Populate event with a fake title based on the current state.
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07002090 // TODO: When can workspace be null?
2091 text.add(mWorkspace == null
Sunny Goyal52e25452020-07-20 12:38:01 -07002092 ? getString(R.string.home_screen)
Sunny Goyalea609262017-10-25 15:47:38 -07002093 : mStateManager.getState().getDescription(this));
Michael Jurkad7c28052012-04-27 15:43:36 -07002094 return result;
2095 }
2096
Sunny Goyal93f878c2016-03-30 17:31:24 -07002097 @Override
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002098 public IntSet getPagesToBindSynchronously(IntArray orderedScreenIds) {
Alex Chau49354042021-08-25 13:21:58 +01002099 IntSet visibleIds;
2100 if (!mPagesToBindSynchronously.isEmpty()) {
2101 visibleIds = mPagesToBindSynchronously;
2102 } else if (!mWorkspaceLoading) {
2103 visibleIds = mWorkspace.getCurrentPageScreenIds();
2104 } else {
2105 // If workspace binding is still in progress, getCurrentPageScreenIds won't be accurate,
2106 // and we should use mSynchronouslyBoundPages that's set during initial binding.
2107 visibleIds = mSynchronouslyBoundPages;
2108 }
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002109 IntArray actualIds = new IntArray();
2110
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002111 IntSet result = new IntSet();
2112 if (visibleIds.isEmpty()) {
2113 return result;
2114 }
2115 for (int id : orderedScreenIds.toArray()) {
Alex Chau1e448462021-08-13 21:48:35 +01002116 actualIds.add(id);
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002117 }
2118 int firstId = visibleIds.getArray().get(0);
Steven Ng4b346102021-09-14 19:17:09 +01002119 int pairId = mWorkspace.getScreenPair(firstId);
Alex Chau62f129b2021-09-03 16:54:27 +01002120 // Double check that actual screenIds contains the visibleId, as empty screens are hidden
2121 // in single panel.
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002122 if (actualIds.contains(firstId)) {
2123 result.add(firstId);
Alex Chau62f129b2021-09-03 16:54:27 +01002124 if (mDeviceProfile.isTwoPanels && actualIds.contains(pairId)) {
2125 result.add(pairId);
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002126 }
Alex Chau62f129b2021-09-03 16:54:27 +01002127 } else if (LauncherAppState.getIDP(this).supportedProfiles.stream().anyMatch(
2128 deviceProfile -> deviceProfile.isTwoPanels) && actualIds.contains(pairId)) {
2129 // Add the right panel if left panel is hidden when switching display, due to empty
2130 // pages being hidden in single panel.
2131 result.add(pairId);
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002132 }
2133 return result;
Joe Onorato9c1289c2009-08-17 11:03:03 -04002134 }
The Android Open Source Projectf96811c2009-03-18 17:39:48 -07002135
Joe Onorato9c1289c2009-08-17 11:03:03 -04002136 /**
Sunny Goyal527c7d32015-08-28 15:19:36 -07002137 * Clear any pending bind callbacks. This is called when is loader is planning to
2138 * perform a full rebind from scratch.
2139 */
2140 @Override
2141 public void clearPendingBinds() {
Sunny Goyal527c7d32015-08-28 15:19:36 -07002142 if (mPendingExecutor != null) {
Sunny Goyal4a48a982021-06-17 15:15:46 -07002143 mPendingExecutor.cancel();
Sunny Goyal527c7d32015-08-28 15:19:36 -07002144 mPendingExecutor = null;
Sunny Goyal6b6d0a32019-08-05 17:19:32 -07002145
2146 // We might have set this flag previously and forgot to clear it.
2147 mAppsView.getAppsStore()
2148 .disableDeferUpdatesSilently(AllAppsStore.DEFER_UPDATES_NEXT_DRAW);
Sunny Goyal527c7d32015-08-28 15:19:36 -07002149 }
2150 }
2151
2152 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04002153 * Refreshes the shortcuts shown on the workspace.
Schneider Victor-tuliasfff7cef2023-04-10 15:59:23 -07002154 * <p>
Joe Onorato9c1289c2009-08-17 11:03:03 -04002155 * Implementation of the method from LauncherModel.Callbacks.
2156 */
Liran Binyamina833af32023-08-02 16:30:27 -04002157 @Override
Joe Onorato9c1289c2009-08-17 11:03:03 -04002158 public void startBinding() {
Sunny Goyal67736672023-06-02 13:35:19 +00002159 TraceHelper.INSTANCE.beginSection("startBinding");
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07002160 // Floating panels (except the full widget sheet) are associated with individual icons. If
2161 // we are starting a fresh bind, close all such panels as all the icons are about
2162 // to go away.
Pinyao Tinga74b63a2019-07-17 23:26:06 -07002163 AbstractFloatingView.closeOpenViews(this, true, TYPE_ALL & ~TYPE_REBIND_SAFE);
Jon Miranda6dc7f1e2017-02-21 12:37:51 -08002164
Anjali Koppalff7ceff2014-05-01 18:26:37 -07002165 setWorkspaceLoading(true);
Adam Cohen517a7f52014-03-01 12:12:59 -08002166
Winson Chungd64d1762013-08-20 14:37:16 -07002167 // Clear the workspace because it's going to be rebound
Sunny Goyal2db53422019-03-01 16:06:12 -08002168 mDragController.cancelDrag();
2169
Adam Cohendf035382011-04-11 17:22:04 -07002170 mWorkspace.clearDropTargets();
Winson Chung9e6a0a22013-08-27 11:58:12 -07002171 mWorkspace.removeAllWorkspaceScreens();
Sihua Ma0593a0d2022-10-03 16:01:48 -07002172 mAppWidgetHolder.clearViews();
Winson Chungd64d1762013-08-20 14:37:16 -07002173
Winson Chung3d503fb2011-07-13 17:25:49 -07002174 if (mHotseat != null) {
Sunny Goyalc4d32012020-04-03 17:10:11 -07002175 mHotseat.resetLayout(getDeviceProfile().isVerticalBarLayout());
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002176 }
Sunny Goyal67736672023-06-02 13:35:19 +00002177 TraceHelper.INSTANCE.endSection();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002178 }
2179
Adam Cohendcd297f2013-06-18 13:13:40 -07002180 @Override
fbaronc0e687b2023-10-04 12:11:20 -07002181 public void setIsFirstPagePinnedItemEnabled(boolean isFirstPagePinnedItemEnabled) {
2182 mIsFirstPagePinnedItemEnabled = isFirstPagePinnedItemEnabled;
2183 mWorkspace.bindAndInitFirstWorkspaceScreen();
2184 }
2185
2186 @Override
Sunny Goyalefb7e842018-10-04 15:11:00 -07002187 public void bindScreens(IntArray orderedScreenIds) {
fbaronc7a605e2023-08-10 23:39:56 -07002188 mWorkspace.mPageIndicator.setAreScreensBinding(true);
Alex Chau1e448462021-08-13 21:48:35 +01002189 int firstScreenPosition = 0;
fbarone58aaf12023-09-25 11:34:56 -07002190 if ((FeatureFlags.QSB_ON_FIRST_SCREEN
fbaronc0e687b2023-10-04 12:11:20 -07002191 && mIsFirstPagePinnedItemEnabled
fbarone58aaf12023-09-25 11:34:56 -07002192 && !shouldShowFirstPageWidget())
2193 && orderedScreenIds.indexOf(FIRST_SCREEN_ID) != firstScreenPosition) {
2194 orderedScreenIds.removeValue(FIRST_SCREEN_ID);
2195 orderedScreenIds.add(firstScreenPosition, FIRST_SCREEN_ID);
fbaronc0e687b2023-10-04 12:11:20 -07002196 } else if (((!FeatureFlags.QSB_ON_FIRST_SCREEN && !mIsFirstPagePinnedItemEnabled)
fbarone58aaf12023-09-25 11:34:56 -07002197 || shouldShowFirstPageWidget())
2198 && orderedScreenIds.isEmpty()) {
Sunny Goyala9e2f5a2016-06-10 12:22:04 -07002199 // If there are no screens, we need to have an empty screen
Andras Kloczl408a54f2021-08-28 00:59:08 +01002200 mWorkspace.addExtraEmptyScreens();
Adam Cohen5084cba2013-09-03 12:01:16 -07002201 }
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002202 bindAddScreens(orderedScreenIds);
Winson Chung0e6a7132013-08-23 12:55:10 -07002203
Winsonc7d2e832016-07-28 12:24:55 -07002204 // After we have added all the screens, if the wallpaper was locked to the default state,
2205 // then notify to indicate that it can be released and a proper wallpaper offset can be
2206 // computed before the next layout
2207 mWorkspace.unlockWallpaperFromDefaultPageOnNextLayout();
Winson Chung64359a52013-07-08 17:17:08 -07002208 }
2209
Sebastian Francoddd04502023-07-26 15:09:10 -07002210 /**
2211 * Remove odd number because they are already included when isTwoPanels and add the pair screen
2212 * if not present.
2213 */
2214 private IntArray filterTwoPanelScreenIds(IntArray orderedScreenIds) {
2215 IntSet screenIds = IntSet.wrap(orderedScreenIds);
2216 orderedScreenIds.forEach(screenId -> {
2217 if (screenId % 2 == 1) {
2218 screenIds.remove(screenId);
2219 // In case the pair is not added, add it
2220 if (!mWorkspace.containsScreenId(screenId - 1)) {
2221 screenIds.add(screenId - 1);
2222 }
2223 }
2224 });
2225 return screenIds.getArray();
2226 }
2227
Sunny Goyalefb7e842018-10-04 15:11:00 -07002228 private void bindAddScreens(IntArray orderedScreenIds) {
Sebastian Francoddd04502023-07-26 15:09:10 -07002229
Andras Kloczl8c574de2021-08-17 23:12:17 +02002230 if (mDeviceProfile.isTwoPanels) {
Sebastian Francoddd04502023-07-26 15:09:10 -07002231 if (FOLDABLE_SINGLE_PAGE.get()) {
2232 orderedScreenIds = filterTwoPanelScreenIds(orderedScreenIds);
2233 } else {
2234 // Some empty pages might have been removed while the phone was in a single panel
2235 // mode, so we want to add those empty pages back.
2236 IntSet screenIds = IntSet.wrap(orderedScreenIds);
2237 orderedScreenIds.forEach(
2238 screenId -> screenIds.add(mWorkspace.getScreenPair(screenId)));
2239 orderedScreenIds = screenIds.getArray();
2240 }
Andras Kloczl8c574de2021-08-17 23:12:17 +02002241 }
2242
Adam Cohendcd297f2013-06-18 13:13:40 -07002243 int count = orderedScreenIds.size();
2244 for (int i = 0; i < count; i++) {
Sunny Goyalefb7e842018-10-04 15:11:00 -07002245 int screenId = orderedScreenIds.get(i);
fbarone58aaf12023-09-25 11:34:56 -07002246 if (FeatureFlags.QSB_ON_FIRST_SCREEN
fbaronc0e687b2023-10-04 12:11:20 -07002247 && mIsFirstPagePinnedItemEnabled
fbarone58aaf12023-09-25 11:34:56 -07002248 && !shouldShowFirstPageWidget()
2249 && screenId == FIRST_SCREEN_ID) {
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002250 // No need to bind the first screen, as its always bound.
Andras Kloczldbf577a2021-05-26 15:02:52 +02002251 continue;
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002252 }
Andras Kloczldbf577a2021-05-26 15:02:52 +02002253 mWorkspace.insertNewWorkspaceScreenBeforeEmptyScreen(screenId);
Adam Cohendcd297f2013-06-18 13:13:40 -07002254 }
Adam Cohendcd297f2013-06-18 13:13:40 -07002255 }
2256
Sunny Goyalb23980c2017-08-17 07:45:25 -07002257 @Override
Tony Wickham6a71a5b2018-08-21 11:40:23 -07002258 public void preAddApps() {
2259 // If there's an undo snackbar, force it to complete to ensure empty screens are removed
2260 // before trying to add new items.
2261 mModelWriter.commitDelete();
2262 AbstractFloatingView snackbar = AbstractFloatingView.getOpenView(this, TYPE_SNACKBAR);
2263 if (snackbar != null) {
2264 snackbar.post(() -> snackbar.close(true));
2265 }
2266 }
2267
2268 @Override
Sunny Goyalefb7e842018-10-04 15:11:00 -07002269 public void bindAppsAdded(IntArray newScreens, ArrayList<ItemInfo> addNotAnimated,
Sunny Goyal29947f02017-12-18 13:49:44 -08002270 ArrayList<ItemInfo> addAnimated) {
Winson Chungd64d1762013-08-20 14:37:16 -07002271 // Add the new screens
Adam Cohen76a47a12014-02-05 11:47:43 -08002272 if (newScreens != null) {
Alex Chau817e0fa2021-09-08 20:46:32 +01002273 // newScreens can contain an empty right panel that is already bound, but not known
2274 // by BgDataModel.
2275 newScreens.removeAllValues(mWorkspace.mScreenOrder);
Adam Cohen76a47a12014-02-05 11:47:43 -08002276 bindAddScreens(newScreens);
2277 }
Winson Chungd64d1762013-08-20 14:37:16 -07002278
2279 // We add the items without animation on non-visible pages, and with
2280 // animations on the new page (which we will try and snap to).
Adam Cohen76a47a12014-02-05 11:47:43 -08002281 if (addNotAnimated != null && !addNotAnimated.isEmpty()) {
Sunny Goyalb23980c2017-08-17 07:45:25 -07002282 bindItems(addNotAnimated, false);
Winson Chungd64d1762013-08-20 14:37:16 -07002283 }
Adam Cohen76a47a12014-02-05 11:47:43 -08002284 if (addAnimated != null && !addAnimated.isEmpty()) {
Sunny Goyalb23980c2017-08-17 07:45:25 -07002285 bindItems(addAnimated, true);
Winson Chungd64d1762013-08-20 14:37:16 -07002286 }
Winson Chungc58497e2013-09-03 17:48:37 -07002287
Winson Chung87412982013-10-03 18:34:14 -07002288 // Remove the extra empty screen
Sunny Goyal6e379fc2020-03-19 16:08:14 -07002289 mWorkspace.removeExtraEmptyScreen(false);
Winson Chungd64d1762013-08-20 14:37:16 -07002290 }
2291
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002292 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04002293 * Bind the items start-end from the list.
2294 *
2295 * Implementation of the method from LauncherModel.Callbacks.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002296 */
Tony Wickham0bb211a2015-10-02 16:22:08 -07002297 @Override
Sunny Goyalb23980c2017-08-17 07:45:25 -07002298 public void bindItems(final List<ItemInfo> items, final boolean forceAnimateIcons) {
Schneider Victor-tulias68706eb2021-04-29 15:24:54 -07002299 bindItems(items, forceAnimateIcons, /* focusFirstItemForAccessibility= */ false);
2300 }
2301
2302
2303 /**
2304 * Bind the items start-end from the list.
2305 *
2306 * Implementation of the method from LauncherModel.Callbacks.
2307 *
2308 * @param focusFirstItemForAccessibility true iff the first item to be added to the workspace
2309 * should be focused for accessibility.
2310 */
2311 public void bindItems(
2312 final List<ItemInfo> items,
2313 final boolean forceAnimateIcons,
2314 final boolean focusFirstItemForAccessibility) {
Sunny Goyal3be633b2016-12-08 09:59:25 -08002315 // Get the list of added items and intersect them with the set of items here
Rajeev Kumar43c0f582017-06-23 15:34:55 -07002316 final Collection<Animator> bounceAnims = new ArrayList<>();
Schneider Victor-tulias68fb4162021-09-16 13:24:01 -07002317 boolean canAnimatePageChange = canAnimatePageChange();
Shikha Malhotraf78da1b2022-04-11 10:23:18 +00002318 Workspace<?> workspace = mWorkspace;
Sunny Goyalefb7e842018-10-04 15:11:00 -07002319 int newItemsScreenId = -1;
Sunny Goyalb23980c2017-08-17 07:45:25 -07002320 int end = items.size();
Schneider Victor-tulias68706eb2021-04-29 15:24:54 -07002321 View newView = null;
Sunny Goyalb23980c2017-08-17 07:45:25 -07002322 for (int i = 0; i < end; i++) {
Sunny Goyal3be633b2016-12-08 09:59:25 -08002323 final ItemInfo item = items.get(i);
Winson Chung4d279d92011-07-21 11:46:32 -07002324
2325 // Short circuit if we are loading dock items for a configuration which has no dock
2326 if (item.container == LauncherSettings.Favorites.CONTAINER_HOTSEAT &&
2327 mHotseat == null) {
2328 continue;
2329 }
2330
Sunny Goyal639e9062015-08-19 19:17:06 -07002331 final View view;
Joe Onorato9c1289c2009-08-17 11:03:03 -04002332 switch (item.itemType) {
2333 case LauncherSettings.Favorites.ITEM_TYPE_APPLICATION:
Sunny Goyal3be633b2016-12-08 09:59:25 -08002334 case LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT: {
Sunny Goyal95899162019-03-27 16:03:06 -07002335 WorkspaceItemInfo info = (WorkspaceItemInfo) item;
Sunny Goyal639e9062015-08-19 19:17:06 -07002336 view = createShortcut(info);
Joe Onorato9c1289c2009-08-17 11:03:03 -04002337 break;
Sunny Goyal3be633b2016-12-08 09:59:25 -08002338 }
2339 case LauncherSettings.Favorites.ITEM_TYPE_FOLDER: {
Tracy Zhou4d7b2442019-12-09 13:42:57 -08002340 view = FolderIcon.inflateFolderAndIcon(R.layout.folder_icon, this,
Michael Jurka0142d492010-08-25 17:46:15 -07002341 (ViewGroup) workspace.getChildAt(workspace.getCurrentPage()),
Sunny Goyal1cd01b02016-11-09 10:43:58 -08002342 (FolderInfo) item);
Joe Onorato9c1289c2009-08-17 11:03:03 -04002343 break;
Sunny Goyal3be633b2016-12-08 09:59:25 -08002344 }
Jeremy Sim7cf0dd92023-03-24 22:39:45 -07002345 case LauncherSettings.Favorites.ITEM_TYPE_APP_PAIR: {
Jeremy Sim94fd07e2023-04-19 20:56:49 -07002346 view = AppPairIcon.inflateIcon(R.layout.app_pair_icon, this,
2347 (ViewGroup) workspace.getChildAt(workspace.getCurrentPage()),
2348 (FolderInfo) item);
Jeremy Sim7cf0dd92023-03-24 22:39:45 -07002349 break;
2350 }
Sunny Goyal952e63d2017-08-16 04:59:08 -07002351 case LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET:
2352 case LauncherSettings.Favorites.ITEM_TYPE_CUSTOM_APPWIDGET: {
Sunny Goyala9a1a212017-08-18 01:03:21 -07002353 view = inflateAppWidget((LauncherAppWidgetInfo) item);
Sunny Goyalb23980c2017-08-17 07:45:25 -07002354 if (view == null) {
2355 continue;
Sunny Goyal3be633b2016-12-08 09:59:25 -08002356 }
Sunny Goyal3be633b2016-12-08 09:59:25 -08002357 break;
2358 }
Winson Chungc763c4e2013-07-19 13:49:06 -07002359 default:
2360 throw new RuntimeException("Invalid Item Type");
Joe Onorato9c1289c2009-08-17 11:03:03 -04002361 }
Sunny Goyal639e9062015-08-19 19:17:06 -07002362
Samuel Fufaca37b8a2019-08-19 17:04:36 -07002363 /*
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002364 * Remove colliding items.
2365 */
Sunny Goyal669b71f2023-01-27 14:37:07 -08002366 CellPos presenterPos = getCellPosMapper().mapModelToPresenter(item);
2367 if (item.container == CONTAINER_DESKTOP) {
2368 CellLayout cl = mWorkspace.getScreenWithId(presenterPos.screenId);
2369 if (cl != null && cl.isOccupied(presenterPos.cellX, presenterPos.cellY)) {
2370 View v = cl.getChildAt(presenterPos.cellX, presenterPos.cellY);
Jon Miranda0aff1152021-11-05 16:36:07 -07002371 if (v == null) {
2372 Log.e(TAG, "bindItems failed when removing colliding item=" + item);
2373 }
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002374 Object tag = v.getTag();
2375 String desc = "Collision while binding workspace item: " + item
2376 + ". Collides with " + tag;
Zak Cohen3eeb41d2020-02-14 14:15:13 -08002377 if (FeatureFlags.IS_STUDIO_BUILD) {
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002378 throw (new RuntimeException(desc));
2379 } else {
Pinyao Ting6a41d562022-05-10 23:47:36 +00002380 getModelWriter().deleteItemFromDatabase(item, desc);
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002381 continue;
2382 }
2383 }
2384 }
Sunny Goyald5462aa2016-11-22 16:52:39 +05302385 workspace.addInScreenFromBind(view, item);
Schneider Victor-tulias68fb4162021-09-16 13:24:01 -07002386 if (forceAnimateIcons) {
Sunny Goyal639e9062015-08-19 19:17:06 -07002387 // Animate all the applications up now
2388 view.setAlpha(0f);
2389 view.setScaleX(0f);
2390 view.setScaleY(0f);
2391 bounceAnims.add(createNewAppBounceAnimation(view, i));
Sunny Goyal669b71f2023-01-27 14:37:07 -08002392 newItemsScreenId = presenterPos.screenId;
Sunny Goyal639e9062015-08-19 19:17:06 -07002393 }
Schneider Victor-tulias68706eb2021-04-29 15:24:54 -07002394
2395 if (newView == null) {
2396 newView = view;
2397 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002398 }
Winson Chungf0c6ae02012-03-21 16:10:31 -07002399
Schneider Victor-tulias68706eb2021-04-29 15:24:54 -07002400 View viewToFocus = newView;
2401 // Animate to the correct pager
Schneider Victor-tulias68fb4162021-09-16 13:24:01 -07002402 if (forceAnimateIcons && newItemsScreenId > -1) {
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002403 AnimatorSet anim = new AnimatorSet();
2404 anim.playTogether(bounceAnims);
Schneider Victor-tulias68706eb2021-04-29 15:24:54 -07002405 if (focusFirstItemForAccessibility && viewToFocus != null) {
2406 anim.addListener(new AnimatorListenerAdapter() {
2407 @Override
2408 public void onAnimationEnd(Animator animation) {
2409 viewToFocus.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_FOCUSED);
2410 }
2411 });
2412 }
Jon Miranda64eb8ea2018-03-29 11:43:58 -07002413
Sunny Goyalefb7e842018-10-04 15:11:00 -07002414 int currentScreenId = mWorkspace.getScreenIdForPageIndex(mWorkspace.getNextPage());
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002415 final int newScreenIndex = mWorkspace.getPageIndexForScreenId(newItemsScreenId);
2416 final Runnable startBounceAnimRunnable = anim::start;
2417
Schneider Victor-tulias68fb4162021-09-16 13:24:01 -07002418 if (canAnimatePageChange && newItemsScreenId != currentScreenId) {
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002419 // We post the animation slightly delayed to prevent slowdowns
2420 // when we are loading right after we return to launcher.
2421 mWorkspace.postDelayed(new Runnable() {
2422 public void run() {
2423 if (mWorkspace != null) {
Andy Wickham65ced1b2020-03-07 02:14:19 +00002424 closeOpenViews(false);
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002425
2426 mWorkspace.snapToPage(newScreenIndex);
2427 mWorkspace.postDelayed(startBounceAnimRunnable,
2428 NEW_APPS_ANIMATION_DELAY);
Winson Chung94d67682013-09-25 16:29:40 -07002429 }
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002430 }
2431 }, NEW_APPS_PAGE_MOVE_DELAY);
2432 } else {
2433 mWorkspace.postDelayed(startBounceAnimRunnable, NEW_APPS_ANIMATION_DELAY);
Winson Chung997a9232013-07-24 15:33:46 -07002434 }
Schneider Victor-tulias68706eb2021-04-29 15:24:54 -07002435 } else if (focusFirstItemForAccessibility && viewToFocus != null) {
2436 viewToFocus.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_FOCUSED);
Winson Chung64359a52013-07-08 17:17:08 -07002437 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04002438 workspace.requestLayout();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002439 }
2440
Joe Onorato9c1289c2009-08-17 11:03:03 -04002441 /**
2442 * Add the views for a widget to the workspace.
Joe Onorato9c1289c2009-08-17 11:03:03 -04002443 */
Sunny Goyala9a1a212017-08-18 01:03:21 -07002444 public void bindAppWidget(LauncherAppWidgetInfo item) {
2445 View view = inflateAppWidget(item);
2446 if (view != null) {
2447 mWorkspace.addInScreen(view, item);
2448 mWorkspace.requestLayout();
2449 }
2450 }
2451
2452 private View inflateAppWidget(LauncherAppWidgetInfo item) {
Samuel Fufaca37b8a2019-08-19 17:04:36 -07002453 if (item.hasOptionFlag(LauncherAppWidgetInfo.OPTION_SEARCH_WIDGET)) {
2454 item.providerName = QsbContainerView.getSearchComponentName(this);
2455 if (item.providerName == null) {
Pinyao Ting6a41d562022-05-10 23:47:36 +00002456 getModelWriter().deleteItemFromDatabase(item,
2457 "search widget removed because search component cannot be found");
Samuel Fufaca37b8a2019-08-19 17:04:36 -07002458 return null;
2459 }
2460 }
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002461 final AppWidgetHostView view;
Sunny Goyal2e1efb42016-03-03 16:58:55 -08002462 if (mIsSafeModeEnabled) {
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002463 view = new PendingAppWidgetHostView(this, item, mIconCache, true);
Sunny Goyald5462aa2016-11-22 16:52:39 +05302464 prepareAppWidget(view, item);
Sunny Goyalb23980c2017-08-17 07:45:25 -07002465 return view;
Sunny Goyal2e1efb42016-03-03 16:58:55 -08002466 }
2467
Sunny Goyal67736672023-06-02 13:35:19 +00002468 TraceHelper.INSTANCE.beginSection("BIND_WIDGET_id=" + item.appWidgetId);
Joe Onorato9c1289c2009-08-17 11:03:03 -04002469
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002470 try {
2471 final LauncherAppWidgetProviderInfo appWidgetInfo;
Steven Ngacd9d792021-06-25 11:51:44 +01002472 String removalReason = "";
Adam Cohen59400422014-03-05 18:07:04 -08002473
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002474 if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY)) {
2475 // If the provider is not ready, bind as a pending widget.
2476 appWidgetInfo = null;
Steven Ngacd9d792021-06-25 11:51:44 +01002477 removalReason = "the provider isn't ready.";
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002478 } else if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)) {
2479 // The widget id is not valid. Try to find the widget based on the provider info.
2480 appWidgetInfo = mAppWidgetManager.findProvider(item.providerName, item.user);
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002481 if (appWidgetInfo == null) {
2482 if (WidgetsModel.GO_DISABLE_WIDGETS) {
Steven Ngacd9d792021-06-25 11:51:44 +01002483 removalReason = "widgets are disabled on go device.";
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002484 } else {
Steven Ngacd9d792021-06-25 11:51:44 +01002485 removalReason =
2486 "WidgetManagerHelper cannot find a provider from provider info.";
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002487 }
2488 }
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002489 } else {
fbaron30d9e3f2023-08-03 17:03:59 -07002490 appWidgetInfo = mAppWidgetManager.getLauncherAppWidgetInfo(item.appWidgetId,
2491 item.getTargetComponent());
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002492 if (appWidgetInfo == null) {
fbaron30d9e3f2023-08-03 17:03:59 -07002493 if (item.appWidgetId <= CUSTOM_WIDGET_ID) {
Steven Ngacd9d792021-06-25 11:51:44 +01002494 removalReason =
2495 "CustomWidgetManager cannot find provider from that widget id.";
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002496 } else {
Steven Ngacd9d792021-06-25 11:51:44 +01002497 removalReason = "AppWidgetManager cannot find provider for that widget id."
2498 + " It could be because AppWidgetService is not available, or the"
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002499 + " appWidgetId has not been bound to a the provider yet, or you"
2500 + " don't have access to that appWidgetId.";
2501 }
2502 }
Sunny Goyalff572272014-07-23 13:58:07 -07002503 }
Sunny Goyalff572272014-07-23 13:58:07 -07002504
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002505 // If the provider is ready, but the width is not yet restored, try to restore it.
2506 if (!item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY)
2507 && (item.restoreStatus != LauncherAppWidgetInfo.RESTORE_COMPLETED)) {
2508 if (appWidgetInfo == null) {
Pinyao Ting6a41d562022-05-10 23:47:36 +00002509 getModelWriter().deleteItemFromDatabase(item,
2510 "Removing restored widget: id=" + item.appWidgetId
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002511 + " belongs to component " + item.providerName + " user " + item.user
Steven Ngacd9d792021-06-25 11:51:44 +01002512 + ", as the provider is null and " + removalReason);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002513 return null;
2514 }
Sunny Goyalff572272014-07-23 13:58:07 -07002515
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002516 // If we do not have a valid id, try to bind an id.
2517 if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)) {
2518 if (!item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_ALLOCATED)) {
2519 // Id has not been allocated yet. Allocate a new id.
Sihua Ma0593a0d2022-10-03 16:01:48 -07002520 item.appWidgetId = mAppWidgetHolder.allocateAppWidgetId();
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002521 item.restoreStatus |= LauncherAppWidgetInfo.FLAG_ID_ALLOCATED;
Sunny Goyal86df1382016-08-10 15:03:22 -07002522
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002523 // Also try to bind the widget. If the bind fails, the user will be shown
2524 // a click to setup UI, which will ask for the bind permission.
Yogisha Dixit658c5da2021-05-24 23:23:15 +01002525 PendingAddWidgetInfo pendingInfo =
2526 new PendingAddWidgetInfo(appWidgetInfo, item.sourceContainer);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002527 pendingInfo.spanX = item.spanX;
2528 pendingInfo.spanY = item.spanY;
2529 pendingInfo.minSpanX = item.minSpanX;
2530 pendingInfo.minSpanY = item.minSpanY;
Sunny Goyal19ff7282021-04-22 10:12:54 -07002531 Bundle options = pendingInfo.getDefaultSizeOptions(this);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002532
2533 boolean isDirectConfig =
2534 item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_DIRECT_CONFIG);
2535 if (isDirectConfig && item.bindOptions != null) {
2536 Bundle newOptions = item.bindOptions.getExtras();
2537 if (options != null) {
2538 newOptions.putAll(options);
2539 }
2540 options = newOptions;
Sunny Goyal86df1382016-08-10 15:03:22 -07002541 }
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002542 boolean success = mAppWidgetManager.bindAppWidgetIdIfAllowed(
2543 item.appWidgetId, appWidgetInfo, options);
2544
2545 // We tried to bind once. If we were not able to bind, we would need to
2546 // go through the permission dialog, which means we cannot skip the config
2547 // activity.
2548 item.bindOptions = null;
2549 item.restoreStatus &= ~LauncherAppWidgetInfo.FLAG_DIRECT_CONFIG;
2550
2551 // Bind succeeded
2552 if (success) {
2553 // If the widget has a configure activity, it is still needs to set it
2554 // up, otherwise the widget is ready to go.
2555 item.restoreStatus = (appWidgetInfo.configure == null) || isDirectConfig
2556 ? LauncherAppWidgetInfo.RESTORE_COMPLETED
2557 : LauncherAppWidgetInfo.FLAG_UI_NOT_READY;
2558 }
2559
2560 getModelWriter().updateItemInDatabase(item);
Sunny Goyal86df1382016-08-10 15:03:22 -07002561 }
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002562 } else if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_UI_NOT_READY)
2563 && (appWidgetInfo.configure == null)) {
2564 // The widget was marked as UI not ready, but there is no configure activity to
2565 // update the UI.
2566 item.restoreStatus = LauncherAppWidgetInfo.RESTORE_COMPLETED;
Sunny Goyal43bf11d2017-02-02 13:52:53 -08002567 getModelWriter().updateItemInDatabase(item);
Sunny Goyalff572272014-07-23 13:58:07 -07002568 }
Samuel Fufa9151c012020-02-24 17:06:28 -08002569 else if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_UI_NOT_READY)
2570 && appWidgetInfo.configure != null) {
2571 if (mAppWidgetManager.isAppWidgetRestored(item.appWidgetId)) {
2572 item.restoreStatus = LauncherAppWidgetInfo.RESTORE_COMPLETED;
2573 getModelWriter().updateItemInDatabase(item);
2574 }
2575 }
Sunny Goyal56c73602015-09-25 12:55:01 -07002576 }
2577
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002578 if (item.restoreStatus == LauncherAppWidgetInfo.RESTORE_COMPLETED) {
2579 // Verify that we own the widget
2580 if (appWidgetInfo == null) {
Pinyao Ting0d97f8d2020-12-04 15:12:26 -08002581 FileLog.e(TAG, "Removing invalid widget: id=" + item.appWidgetId);
Sihua Ma0593a0d2022-10-03 16:01:48 -07002582 getModelWriter().deleteWidgetInfo(item, getAppWidgetHolder(), removalReason);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002583 return null;
2584 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04002585
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002586 item.minSpanX = appWidgetInfo.minSpanX;
2587 item.minSpanY = appWidgetInfo.minSpanY;
Sihua Ma0593a0d2022-10-03 16:01:48 -07002588 view = mAppWidgetHolder.createView(this, item.appWidgetId, appWidgetInfo);
Samuel Fufa9151c012020-02-24 17:06:28 -08002589 } else if (!item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)
2590 && appWidgetInfo != null) {
Sihua Ma0593a0d2022-10-03 16:01:48 -07002591 mAppWidgetHolder.addPendingView(item.appWidgetId,
Samuel Fufa9151c012020-02-24 17:06:28 -08002592 new PendingAppWidgetHostView(this, item, mIconCache, false));
Sihua Ma0593a0d2022-10-03 16:01:48 -07002593 view = mAppWidgetHolder.createView(this, item.appWidgetId, appWidgetInfo);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002594 } else {
2595 view = new PendingAppWidgetHostView(this, item, mIconCache, false);
2596 }
2597 prepareAppWidget(view, item);
2598 } finally {
Sunny Goyal67736672023-06-02 13:35:19 +00002599 TraceHelper.INSTANCE.endSection();
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002600 }
2601
Sunny Goyalb23980c2017-08-17 07:45:25 -07002602 return view;
Joe Onorato9c1289c2009-08-17 11:03:03 -04002603 }
2604
Sunny Goyalff572272014-07-23 13:58:07 -07002605 /**
2606 * Restores a pending widget.
2607 *
2608 * @param appWidgetId The app widget id
Sunny Goyalff572272014-07-23 13:58:07 -07002609 */
Sunny Goyald478c832016-04-01 12:04:16 -07002610 private LauncherAppWidgetInfo completeRestoreAppWidget(int appWidgetId, int finalRestoreFlag) {
Sunny Goyalff572272014-07-23 13:58:07 -07002611 LauncherAppWidgetHostView view = mWorkspace.getWidgetForAppWidgetId(appWidgetId);
2612 if ((view == null) || !(view instanceof PendingAppWidgetHostView)) {
2613 Log.e(TAG, "Widget update called, when the widget no longer exists.");
Sunny Goyald478c832016-04-01 12:04:16 -07002614 return null;
Sunny Goyalff572272014-07-23 13:58:07 -07002615 }
2616
Sunny Goyal0fc1be12014-08-11 17:05:23 -07002617 LauncherAppWidgetInfo info = (LauncherAppWidgetInfo) view.getTag();
Sunny Goyald478c832016-04-01 12:04:16 -07002618 info.restoreStatus = finalRestoreFlag;
Jon Miranda2b823f42017-05-02 18:36:18 -07002619 if (info.restoreStatus == LauncherAppWidgetInfo.RESTORE_COMPLETED) {
2620 info.pendingItemInfo = null;
2621 }
Sunny Goyalff572272014-07-23 13:58:07 -07002622
Sunny Goyalba47faa2017-10-04 16:50:57 -07002623 if (((PendingAppWidgetHostView) view).isReinflateIfNeeded()) {
Sunny Goyal29947f02017-12-18 13:49:44 -08002624 view.reInflate();
Sunny Goyalba47faa2017-10-04 16:50:57 -07002625 }
2626
Sunny Goyal43bf11d2017-02-02 13:52:53 -08002627 getModelWriter().updateItemInDatabase(info);
Sunny Goyald478c832016-04-01 12:04:16 -07002628 return info;
Sunny Goyalff572272014-07-23 13:58:07 -07002629 }
2630
Sunny Goyal527c7d32015-08-28 15:19:36 -07002631 public void clearPendingExecutor(ViewOnDrawExecutor executor) {
2632 if (mPendingExecutor == executor) {
2633 mPendingExecutor = null;
2634 }
2635 }
2636
Sunny Goyalb5b9ad62016-04-02 11:23:39 -07002637 @Override
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -07002638 @TargetApi(Build.VERSION_CODES.S)
Fengjiang Li5a36c172023-04-13 18:18:27 +00002639 public void onInitialBindComplete(IntSet boundPages, RunnableList pendingTasks,
2640 int workspaceItemCount, boolean isBindSync) {
Sunny Goyal4a48a982021-06-17 15:15:46 -07002641 mSynchronouslyBoundPages = boundPages;
Sunny Goyal4a48a982021-06-17 15:15:46 -07002642 mPagesToBindSynchronously = new IntSet();
2643
2644 clearPendingBinds();
2645 ViewOnDrawExecutor executor = new ViewOnDrawExecutor(pendingTasks);
2646 mPendingExecutor = executor;
2647 if (!isInState(ALL_APPS)) {
2648 mAppsView.getAppsStore().enableDeferUpdates(AllAppsStore.DEFER_UPDATES_NEXT_DRAW);
2649 pendingTasks.add(() -> mAppsView.getAppsStore().disableDeferUpdates(
2650 AllAppsStore.DEFER_UPDATES_NEXT_DRAW));
2651 }
2652
Sunny Goyal7b8d63f2022-04-14 16:37:32 -07002653 if (mOnInitialBindListener != null) {
2654 getRootView().getViewTreeObserver().removeOnPreDrawListener(mOnInitialBindListener);
2655 mOnInitialBindListener = null;
Sunny Goyalb5b9ad62016-04-02 11:23:39 -07002656 }
Sunny Goyal7b8d63f2022-04-14 16:37:32 -07002657
2658 executor.onLoadAnimationCompleted();
Sunny Goyal4a48a982021-06-17 15:15:46 -07002659 executor.attachTo(this);
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -07002660 if (Utilities.ATLEAST_S) {
2661 Trace.endAsyncSection(DISPLAY_WORKSPACE_TRACE_METHOD_NAME,
2662 DISPLAY_WORKSPACE_TRACE_COOKIE);
2663 }
Fengjiang Li5a36c172023-04-13 18:18:27 +00002664 mStartupLatencyLogger
2665 .logCardinality(workspaceItemCount)
2666 .logEnd(isBindSync
2667 ? LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_SYNC
2668 : LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_ASYNC);
2669 // In the first rootview's onDraw after onInitialBindComplete(), log end of startup latency.
2670 getRootView().getViewTreeObserver().addOnDrawListener(
2671 new ViewTreeObserver.OnDrawListener() {
2672
2673 @Override
2674 public void onDraw() {
2675 mStartupLatencyLogger
2676 .logEnd(LAUNCHER_LATENCY_STARTUP_TOTAL_DURATION)
2677 .log()
2678 .reset();
2679 MAIN_EXECUTOR.getHandler().postAtFrontOfQueue(
2680 () -> getRootView().getViewTreeObserver()
2681 .removeOnDrawListener(this));
2682 }
2683 });
Sunny Goyalb5b9ad62016-04-02 11:23:39 -07002684 }
2685
Joe Onorato9c1289c2009-08-17 11:03:03 -04002686 /**
2687 * Callback saying that there aren't any more items to bind.
Schneider Victor-tuliasfff7cef2023-04-10 15:59:23 -07002688 * <p>
Joe Onorato9c1289c2009-08-17 11:03:03 -04002689 * Implementation of the method from LauncherModel.Callbacks.
2690 */
Andras Kloczl55edfe52021-05-14 12:21:30 +02002691 public void finishBindingItems(IntSet pagesBoundFirst) {
Sunny Goyal67736672023-06-02 13:35:19 +00002692 TraceHelper.INSTANCE.beginSection("finishBindingItems");
Adam Cohen1462de32012-07-24 22:34:36 -07002693 mWorkspace.restoreInstanceStateForRemainingPages();
Joe Onorato9c1289c2009-08-17 11:03:03 -04002694
Anjali Koppalff7ceff2014-05-01 18:26:37 -07002695 setWorkspaceLoading(false);
Adam Cohendb364c32014-05-20 14:23:40 -07002696
Sunny Goyal2100c782016-08-22 16:00:03 -07002697 if (mPendingActivityResult != null) {
2698 handleActivityResult(mPendingActivityResult.requestCode,
2699 mPendingActivityResult.resultCode, mPendingActivityResult.data);
2700 mPendingActivityResult = null;
Adam Cohendb364c32014-05-20 14:23:40 -07002701 }
2702
Andras Kloczl55edfe52021-05-14 12:21:30 +02002703 int currentPage = pagesBoundFirst != null && !pagesBoundFirst.isEmpty()
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002704 ? mWorkspace.getPageIndexForScreenId(pagesBoundFirst.getArray().get(0))
2705 : PagedView.INVALID_PAGE;
Tonyf80e8932018-12-21 11:58:04 -08002706 // When undoing the removal of the last item on a page, return to that page.
Tony Wickham03f27012019-04-25 14:22:54 -07002707 // Since we are just resetting the current page without user interaction,
2708 // override the previous page so we don't log the page switch.
Andras Kloczl55edfe52021-05-14 12:21:30 +02002709 mWorkspace.setCurrentPage(currentPage, currentPage /* overridePrevPage */);
2710 mPagesToBindSynchronously = new IntSet();
Tony Wickham6a71a5b2018-08-21 11:40:23 -07002711
Sunny Goyalac6f69f2019-08-16 11:59:55 -07002712 // Cache one page worth of icons
2713 getViewCache().setCacheSize(R.layout.folder_application,
2714 mDeviceProfile.inv.numFolderColumns * mDeviceProfile.inv.numFolderRows);
2715 getViewCache().setCacheSize(R.layout.folder_page, 2);
2716
Sunny Goyal67736672023-06-02 13:35:19 +00002717 TraceHelper.INSTANCE.endSection();
fbaronc7a605e2023-08-10 23:39:56 -07002718 mWorkspace.removeExtraEmptyScreen(/* stripEmptyScreens= */ true);
2719 mWorkspace.mPageIndicator.setAreScreensBinding(false);
Winson Chungf0c6ae02012-03-21 16:10:31 -07002720 }
2721
Schneider Victor-tulias68fb4162021-09-16 13:24:01 -07002722 private boolean canAnimatePageChange() {
Sunny Goyal9b180102020-03-11 10:02:29 -07002723 if (mDragController.isDragging()) {
2724 return false;
2725 } else {
Riddle Hsu979da642020-09-22 21:52:40 +08002726 return (SystemClock.uptimeMillis() - mLastTouchUpTime)
Sunny Goyal9b180102020-03-11 10:02:29 -07002727 > (NEW_APPS_ANIMATION_INACTIVE_TIMEOUT_SECONDS * 1000);
2728 }
Winson Chunga2413752012-04-03 14:22:34 -07002729 }
2730
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002731 /**
2732 * Similar to {@link #getFirstMatch} but optimized to finding a suitable view for the app close
2733 * animation.
2734 *
2735 * @param preferredItemId The id of the preferred item to match to if it exists.
2736 * @param packageName The package name of the app to match.
2737 * @param user The user of the app to match.
Jon Mirandab42e1242022-03-08 16:37:35 -08002738 * @param supportsAllAppsState If true and we are in All Apps state, looks for view in All Apps.
2739 * Else we only looks on the workspace.
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002740 */
Jon Mirandaf58db152022-06-02 16:06:37 -07002741 public @Nullable View getFirstMatchForAppClose(int preferredItemId, String packageName,
2742 UserHandle user, boolean supportsAllAppsState) {
Sunny Goyal32084d42022-05-02 10:00:07 -07002743 final Predicate<ItemInfo> preferredItem = info ->
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002744 info != null && info.id == preferredItemId;
Sunny Goyal32084d42022-05-02 10:00:07 -07002745 final Predicate<ItemInfo> packageAndUserAndApp = info ->
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002746 info != null
2747 && info.itemType == ITEM_TYPE_APPLICATION
2748 && info.user.equals(user)
2749 && info.getTargetComponent() != null
2750 && TextUtils.equals(info.getTargetComponent().getPackageName(),
2751 packageName);
2752
Jon Mirandab42e1242022-03-08 16:37:35 -08002753 if (supportsAllAppsState && isInState(LauncherState.ALL_APPS)) {
Jon Mirandaf58db152022-06-02 16:06:37 -07002754 AllAppsRecyclerView activeRecyclerView = mAppsView.getActiveRecyclerView();
2755 View v = getFirstMatch(Collections.singletonList(activeRecyclerView),
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002756 preferredItem, packageAndUserAndApp);
Jon Mirandaf58db152022-06-02 16:06:37 -07002757
Sunny Goyalf34811d2022-10-21 20:42:34 +00002758 if (v != null && activeRecyclerView.computeVerticalScrollOffset() > 0) {
Jon Mirandaf58db152022-06-02 16:06:37 -07002759 RectF locationBounds = new RectF();
2760 FloatingIconView.getLocationBoundsForView(this, v, false, locationBounds,
2761 new Rect());
2762 if (locationBounds.top < mAppsView.getHeaderBottom()) {
2763 // Icon is covered by scrim, return null to play fallback animation.
2764 return null;
2765 }
2766 }
2767
2768 return v;
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002769 }
Federico Baron8bf1bca2022-09-27 16:19:11 -07002770
2771 // Look for the item inside the folder at the current page
2772 Folder folder = Folder.getOpen(this);
2773 if (folder != null) {
2774 View v = getFirstMatch(Collections.singletonList(
2775 folder.getContent().getCurrentCellLayout().getShortcutsAndWidgets()),
2776 preferredItem,
2777 packageAndUserAndApp);
2778 if (v == null) {
2779 folder.close(isStarted() && !isForceInvisible());
2780 } else {
2781 return v;
2782 }
2783 }
2784
2785 List<ViewGroup> containers = new ArrayList<>(mWorkspace.getPanelCount() + 1);
2786 containers.add(mWorkspace.getHotseat().getShortcutsAndWidgets());
2787 mWorkspace.forEachVisiblePage(page
2788 -> containers.add(((CellLayout) page).getShortcutsAndWidgets()));
2789
2790 // Order: Preferred item by itself or in folder, then by matching package/user
2791 return getFirstMatch(containers, preferredItem, forFolderMatch(preferredItem),
2792 packageAndUserAndApp, forFolderMatch(packageAndUserAndApp));
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002793 }
2794
2795 /**
2796 * Finds the first view matching the ordered operators across the given viewgroups in order.
2797 * @param containers List of ViewGroups to scan, in order of preference.
2798 * @param operators List of operators, in order starting from best matching operator.
2799 */
Jon Mirandaf26bdcb2022-06-09 16:09:30 -07002800 @Nullable
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002801 private static View getFirstMatch(Iterable<ViewGroup> containers,
Sunny Goyal32084d42022-05-02 10:00:07 -07002802 final Predicate<ItemInfo>... operators) {
2803 for (Predicate<ItemInfo> operator : operators) {
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002804 for (ViewGroup container : containers) {
2805 View match = mapOverViewGroup(container, operator);
2806 if (match != null) {
2807 return match;
2808 }
2809 }
2810 }
2811 return null;
2812 }
2813
2814 /**
2815 * Returns the first view matching the operator in the given ViewGroups, or null if none.
2816 * Forward iteration matters.
2817 */
Jon Mirandaf26bdcb2022-06-09 16:09:30 -07002818 @Nullable
Sunny Goyal32084d42022-05-02 10:00:07 -07002819 private static View mapOverViewGroup(ViewGroup container, Predicate<ItemInfo> op) {
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002820 final int itemCount = container.getChildCount();
2821 for (int itemIdx = 0; itemIdx < itemCount; itemIdx++) {
2822 View item = container.getChildAt(itemIdx);
Sunny Goyal32084d42022-05-02 10:00:07 -07002823 if (op.test((ItemInfo) item.getTag())) {
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002824 return item;
2825 }
2826 }
2827 return null;
2828 }
2829
Winson Chungc9168342013-06-26 14:54:55 -07002830 private ValueAnimator createNewAppBounceAnimation(View v, int i) {
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002831 ValueAnimator bounceAnim = new PropertyListBuilder().alpha(1).scale(1).build(v)
Sunny Goyal60e68c92020-08-12 13:59:27 -07002832 .setDuration(ItemInstallQueue.NEW_SHORTCUT_BOUNCE_DURATION);
2833 bounceAnim.setStartDelay(i * ItemInstallQueue.NEW_SHORTCUT_STAGGER_DELAY);
Sunny Goyal5a1f53b2015-05-27 10:24:24 -07002834 bounceAnim.setInterpolator(new OvershootInterpolator(BOUNCE_ANIMATION_TENSION));
Winson Chungc9168342013-06-26 14:54:55 -07002835 return bounceAnim;
2836 }
2837
Pinyao Tingc9074272019-11-11 11:51:44 -08002838 private void announceForAccessibility(@StringRes int stringResId) {
2839 getDragLayer().announceForAccessibility(getString(stringResId));
2840 }
2841
Amith Yamasani6d7fe502010-11-16 09:05:07 -08002842 /**
Josh Tsuji231c9222022-01-11 20:43:59 -05002843 * Informs us that the overlay (-1 screen, typically), has either become visible or invisible.
2844 */
Sunny Goyal82379182022-11-02 18:58:49 -07002845 public void onOverlayVisibilityChanged(boolean visible) {
2846 getStatsLogManager().logger()
2847 .withSrcState(LAUNCHER_STATE_HOME)
2848 .withDstState(LAUNCHER_STATE_HOME)
2849 .withContainerInfo(LauncherAtom.ContainerInfo.newBuilder()
2850 .setWorkspace(WorkspaceContainer.newBuilder()
2851 .setPageIndex(visible ? 0 : -1))
2852 .build())
2853 .log(visible ? LAUNCHER_SWIPELEFT : LAUNCHER_SWIPERIGHT);
2854 }
Josh Tsuji231c9222022-01-11 20:43:59 -05002855
2856 /**
2857 * Informs us that the page transition has ended, so that we can react to the newly selected
2858 * page if we want to.
2859 */
2860 public void onPageEndTransition() {}
2861
2862 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04002863 * Add the icons for all apps.
2864 *
2865 * Implementation of the method from LauncherModel.Callbacks.
2866 */
Sunny Goyal28daf4a2020-06-08 17:06:09 -07002867 @Override
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -07002868 @TargetApi(Build.VERSION_CODES.S)
Anushree Ganjam97434ee2023-05-18 22:03:16 +00002869 @UiThread
2870 public void bindAllApplications(AppInfo[] apps, int flags,
2871 Map<PackageUserKey, Integer> packageUserKeytoUidMap) {
2872 Preconditions.assertUIThread();
Sunny Goyalc80e60d2023-06-07 12:52:30 -07002873 boolean hadWorkApps = mAppsView.shouldShowTabs();
Brian Isganitise9eacb32023-07-06 22:25:18 +00002874 AllAppsStore<Launcher> appsStore = mAppsView.getAppsStore();
Anushree Ganjam97434ee2023-05-18 22:03:16 +00002875 appsStore.setApps(apps, flags, packageUserKeytoUidMap);
Sunny Goyal1818fb72020-11-09 14:32:48 -08002876 PopupContainerWithArrow.dismissInvalidPopup(this);
Sunny Goyalc80e60d2023-06-07 12:52:30 -07002877 if (hadWorkApps != mAppsView.shouldShowTabs()) {
2878 getStateManager().goToState(NORMAL);
2879 }
2880
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -07002881 if (Utilities.ATLEAST_S) {
2882 Trace.endAsyncSection(DISPLAY_ALL_APPS_TRACE_METHOD_NAME,
2883 DISPLAY_ALL_APPS_TRACE_COOKIE);
2884 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04002885 }
2886
2887 /**
Zak Cohen658c67a2018-10-19 14:21:05 -07002888 * Copies LauncherModel's map of activities to shortcut counts to Launcher's. This is necessary
Tony Wickhambfbf7f92016-05-19 11:19:39 -07002889 * because LauncherModel's map is updated in the background, while Launcher runs on the UI.
2890 */
2891 @Override
Zak Cohen658c67a2018-10-19 14:21:05 -07002892 public void bindDeepShortcutMap(HashMap<ComponentKey, Integer> deepShortcutMapCopy) {
Tony Wickham010d2552017-01-20 08:15:28 -08002893 mPopupDataProvider.setDeepShortcutMap(deepShortcutMapCopy);
Tony Wickham1bce7fd2016-04-28 17:39:03 -07002894 }
2895
Sunny Goyal4390ace2014-10-13 11:33:11 -07002896 @Override
Schneider Victor-tulias6a5f4312021-01-12 19:30:02 +00002897 public void bindIncrementalDownloadProgressUpdated(AppInfo app) {
2898 mAppsView.getAppsStore().updateProgressBar(app);
Mario Bertschler08ffaae2017-03-20 11:30:27 -07002899 }
2900
2901 @Override
Sunny Goyal29947f02017-12-18 13:49:44 -08002902 public void bindWidgetsRestored(ArrayList<LauncherAppWidgetInfo> widgets) {
Sunny Goyal4390ace2014-10-13 11:33:11 -07002903 mWorkspace.widgetsRestored(widgets);
2904 }
2905
Joe Onorato9c1289c2009-08-17 11:03:03 -04002906 /**
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07002907 * Some shortcuts were updated in the background.
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07002908 * Implementation of the method from LauncherModel.Callbacks.
Sunny Goyald3b87ef2016-07-28 12:11:54 -07002909 *
2910 * @param updated list of shortcuts which have changed.
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07002911 */
Sunny Goyal4390ace2014-10-13 11:33:11 -07002912 @Override
Sunny Goyal28f50752020-07-21 14:15:13 -07002913 public void bindWorkspaceItemsChanged(List<WorkspaceItemInfo> updated) {
Sunny Goyal4390ace2014-10-13 11:33:11 -07002914 if (!updated.isEmpty()) {
Sunny Goyal711c5962021-06-23 12:36:18 -07002915 mWorkspace.updateWorkspaceItems(updated, this);
Sunny Goyal1818fb72020-11-09 14:32:48 -08002916 PopupContainerWithArrow.dismissInvalidPopup(this);
Sunny Goyal4390ace2014-10-13 11:33:11 -07002917 }
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07002918 }
2919
2920 /**
Chris Wrenaeff7ea2014-02-14 16:59:24 -05002921 * Update the state of a package, typically related to install state.
2922 *
2923 * Implementation of the method from LauncherModel.Callbacks.
2924 */
Sunny Goyale755d462014-07-22 13:48:29 -07002925 @Override
Sunny Goyal29947f02017-12-18 13:49:44 -08002926 public void bindRestoreItemsChange(HashSet<ItemInfo> updates) {
Sunny Goyal711c5962021-06-23 12:36:18 -07002927 mWorkspace.updateRestoreItems(updates, this);
Sunny Goyala22666f2014-09-18 13:25:15 -07002928 }
2929
2930 /**
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07002931 * A package was uninstalled/updated. We take both the super set of packageNames
Winson Chung83892cc2013-05-01 16:53:33 -07002932 * in addition to specific applications to remove, the reason being that
2933 * this can be called when a package is updated as well. In that scenario,
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07002934 * we only remove specific components from the workspace and hotseat, where as
Winson Chung83892cc2013-05-01 16:53:33 -07002935 * package-removal should clear all items by package name.
Joe Onorato9c1289c2009-08-17 11:03:03 -04002936 */
Sunny Goyal1a745e82014-10-02 15:58:31 -07002937 @Override
Sunny Goyal32084d42022-05-02 10:00:07 -07002938 public void bindWorkspaceComponentsRemoved(Predicate<ItemInfo> matcher) {
Sunny Goyal6e13dd32017-08-17 03:01:19 -07002939 mWorkspace.removeItemsByMatcher(matcher);
2940 mDragController.onAppsRemoved(matcher);
Sunny Goyal1818fb72020-11-09 14:32:48 -08002941 PopupContainerWithArrow.dismissInvalidPopup(this);
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07002942 }
Sunny Goyal4390ace2014-10-13 11:33:11 -07002943
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07002944 @Override
Steven Ng2f5648a2021-02-08 17:18:25 +00002945 public void bindAllWidgets(final List<WidgetsListBaseEntry> allWidgets) {
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07002946 mPopupDataProvider.setAllWidgets(allWidgets);
Tony Wickham26b17462017-03-20 17:12:24 -07002947 }
2948
kholoud mohamedc76b2032021-12-20 16:47:38 +00002949 @Override
fbarone58aaf12023-09-25 11:34:56 -07002950 public void bindSmartspaceWidget() {
2951 CellLayout cl = mWorkspace.getScreenWithId(FIRST_SCREEN_ID);
2952 int spanX = InvariantDeviceProfile.INSTANCE.get(this).numSearchContainerColumns;
2953 if (cl != null) {
2954 for (int col = 0; col < spanX; col++) {
2955 if (cl.isOccupied(col, 0)) {
2956 return;
2957 }
2958 }
2959 } else {
2960 return;
2961 }
2962
2963 WidgetsListBaseEntry widgetsListBaseEntry = getPopupDataProvider()
2964 .getAllWidgets().stream().filter(
2965 item -> item.mPkgItem.packageName.equals(
2966 APPLICATION_ID))
2967 .findFirst()
2968 .orElse(null);
2969 if (widgetsListBaseEntry != null) {
2970 LauncherAppWidgetProviderInfo launcherAppWidgetProviderInfo =
2971 widgetsListBaseEntry.mWidgets.get(0).widgetInfo;
2972 PendingAddWidgetInfo info = new PendingAddWidgetInfo(launcherAppWidgetProviderInfo,
2973 CONTAINER_DESKTOP);
2974 addPendingItem(info, info.container, FIRST_SCREEN_ID, new int[]{0, 0}, info.spanX,
2975 info.spanY);
2976 }
2977 }
2978
2979 @Override
kholoud mohamedc76b2032021-12-20 16:47:38 +00002980 public void bindStringCache(StringCache cache) {
2981 mStringCache = cache;
Brandon Dayauon076dcdf2023-06-08 13:52:06 -07002982 mAppsView.updateWorkUI();
kholoud mohamedc76b2032021-12-20 16:47:38 +00002983 }
2984
Tony Wickham86222d22017-03-29 15:30:43 -07002985 /**
2986 * @param packageUser if null, refreshes all widgets and shortcuts, otherwise only
2987 * refreshes the widgets and shortcuts associated with the given package/user
2988 */
2989 public void refreshAndBindWidgetsForPackageUser(@Nullable PackageUserKey packageUser) {
Sunny Goyalc6e97692017-06-02 13:46:55 -07002990 mModel.refreshAndBindWidgetsAndShortcuts(packageUser);
Sunny Goyal2e1efb42016-03-03 16:58:55 -08002991 }
2992
Winson Chung80baf5a2010-08-09 16:03:15 -07002993 /**
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08002994 * $ adb shell dumpsys activity com.android.launcher3.Launcher [--all]
Joe Onoratobe386092009-11-17 17:32:16 -08002995 */
Adam Cohen16d7ffc2011-10-05 17:49:14 -07002996 @Override
2997 public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) {
2998 super.dump(prefix, fd, writer, args);
Sunny Goyala1365452015-10-01 15:46:24 -07002999
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08003000 if (args.length > 0 && TextUtils.equals(args[0], "--all")) {
3001 writer.println(prefix + "Workspace Items");
Sunny Goyal7ce471b2017-08-02 03:37:39 -07003002 for (int i = 0; i < mWorkspace.getPageCount(); i++) {
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08003003 writer.println(prefix + " Homescreen " + i);
3004
3005 ViewGroup layout = ((CellLayout) mWorkspace.getPageAt(i)).getShortcutsAndWidgets();
3006 for (int j = 0; j < layout.getChildCount(); j++) {
3007 Object tag = layout.getChildAt(j).getTag();
3008 if (tag != null) {
3009 writer.println(prefix + " " + tag.toString());
3010 }
3011 }
3012 }
3013
3014 writer.println(prefix + " Hotseat");
Sunny Goyal876e4622018-11-02 13:50:40 -07003015 ViewGroup layout = mHotseat.getShortcutsAndWidgets();
Sunny Goyala1365452015-10-01 15:46:24 -07003016 for (int j = 0; j < layout.getChildCount(); j++) {
3017 Object tag = layout.getChildAt(j).getTag();
3018 if (tag != null) {
3019 writer.println(prefix + " " + tag.toString());
3020 }
Adam Cohen4caf2982013-08-20 18:54:31 -07003021 }
Sunny Goyala1365452015-10-01 15:46:24 -07003022 }
3023
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08003024 writer.println(prefix + "Misc:");
Winson Chungef528762019-09-06 12:05:52 -07003025 dumpMisc(prefix + "\t", writer);
3026 writer.println(prefix + "\tmWorkspaceLoading=" + mWorkspaceLoading);
3027 writer.println(prefix + "\tmPendingRequestArgs=" + mPendingRequestArgs
3028 + " mPendingActivityResult=" + mPendingActivityResult);
3029 writer.println(prefix + "\tmRotationHelper: " + mRotationHelper);
Sihua Ma0593a0d2022-10-03 16:01:48 -07003030 writer.println(prefix + "\tmAppWidgetHolder.isListening: "
3031 + mAppWidgetHolder.isListening());
Winson Chungef528762019-09-06 12:05:52 -07003032
Tony Wickham646e4482020-04-06 17:25:53 -07003033 // Extra logging for general debugging
Hyunyoung Songa310a802019-04-25 13:57:16 -07003034 mDragLayer.dump(prefix, writer);
3035 mStateManager.dump(prefix, writer);
Tony Wickham646e4482020-04-06 17:25:53 -07003036 mPopupDataProvider.dump(prefix, writer);
Pat Manning5f74bfd2022-07-20 12:08:54 +01003037 mDeviceProfile.dump(this, prefix, writer);
Kevin Lim07546b82023-09-25 21:02:56 +00003038 mAppsView.getAppsStore().dump(prefix, writer);
Sunny Goyal2bba1902018-02-27 12:20:50 -08003039
3040 try {
3041 FileLog.flushAll(writer);
3042 } catch (Exception e) {
3043 // Ignore
3044 }
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08003045
3046 mModel.dumpState(prefix, fd, writer, args);
Sunny Goyala1365452015-10-01 15:46:24 -07003047
Adam Cohen9211d422014-10-07 18:14:53 -07003048 if (mLauncherCallbacks != null) {
3049 mLauncherCallbacks.dump(prefix, fd, writer, args);
3050 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -07003051 mOverlayManager.dump(prefix, writer);
Adam Cohen16d7ffc2011-10-05 17:49:14 -07003052 }
Adam Cohen487f7dd2012-06-28 18:12:10 -07003053
Sebastian Franco4080fdd2023-09-19 14:17:23 -07003054 /**
3055 * Populates the list of shortcuts. Logic delegated to {@Link KeyboardShortcutsDelegate}.
3056 *
3057 * @param data The data list to populate with shortcuts.
3058 * @param menu The current menu, which may be null.
3059 * @param deviceId The id for the connected device the shortcuts should be provided for.
3060 */
Sunny Goyal66b24572016-09-21 15:57:55 -07003061 @Override
Sunny Goyal66b24572016-09-21 15:57:55 -07003062 public void onProvideKeyboardShortcuts(
3063 List<KeyboardShortcutGroup> data, Menu menu, int deviceId) {
Sebastian Franco4080fdd2023-09-19 14:17:23 -07003064 mKeyboardShortcutsDelegate.onProvideKeyboardShortcuts(data, menu, deviceId);
Sunny Goyal66b24572016-09-21 15:57:55 -07003065 super.onProvideKeyboardShortcuts(data, menu, deviceId);
3066 }
3067
Sebastian Franco4080fdd2023-09-19 14:17:23 -07003068 /**
3069 * Logic delegated to {@Link KeyboardShortcutsDelegate}.
3070 * @param keyCode The value in event.getKeyCode().
3071 * @param event Description of the key event.
3072 */
Sunny Goyal66b24572016-09-21 15:57:55 -07003073 @Override
3074 public boolean onKeyShortcut(int keyCode, KeyEvent event) {
Sebastian Franco4080fdd2023-09-19 14:17:23 -07003075 Boolean result = mKeyboardShortcutsDelegate.onKeyShortcut(keyCode, event);
3076 return result != null ? result : super.onKeyShortcut(keyCode, event);
Sunny Goyal66b24572016-09-21 15:57:55 -07003077 }
3078
Sebastian Franco4080fdd2023-09-19 14:17:23 -07003079 /**
3080 * Logic delegated to {@Link KeyboardShortcutsDelegate}.
3081 * @param keyCode The value in event.getKeyCode().
3082 * @param event Description of the key event.
3083 */
Vadim Tryshev646a0dd2018-02-05 16:27:50 -08003084 @Override
Josep del Rio1d976c62023-05-04 16:07:50 +00003085 public boolean onKeyDown(int keyCode, KeyEvent event) {
Sebastian Franco4080fdd2023-09-19 14:17:23 -07003086 Boolean result = mKeyboardShortcutsDelegate.onKeyDown(keyCode, event);
3087 return result != null ? result : super.onKeyDown(keyCode, event);
Josep del Rio1d976c62023-05-04 16:07:50 +00003088 }
3089
Sebastian Franco4080fdd2023-09-19 14:17:23 -07003090 /**
3091 * Logic delegated to {@Link KeyboardShortcutsDelegate}.
3092 * @param keyCode The value in event.getKeyCode().
3093 * @param event Description of the key event.
3094 */
Josep del Rio1d976c62023-05-04 16:07:50 +00003095 @Override
Vadim Tryshev646a0dd2018-02-05 16:27:50 -08003096 public boolean onKeyUp(int keyCode, KeyEvent event) {
Sebastian Franco4080fdd2023-09-19 14:17:23 -07003097 Boolean result = mKeyboardShortcutsDelegate.onKeyUp(keyCode, event);
3098 return result != null ? result : super.onKeyUp(keyCode, event);
Vadim Tryshev646a0dd2018-02-05 16:27:50 -08003099 }
3100
Sunny Goyal831212e2021-05-14 14:24:09 -07003101 /**
3102 * Shows the default options popup
3103 */
3104 public void showDefaultOptions(float x, float y) {
Brian Isganitisa85ae692021-09-23 19:56:24 -04003105 OptionsPopupView.show(this, getPopupTarget(x, y), OptionsPopupView.getOptions(this),
3106 false);
3107 }
3108
Brian Isganitisa85ae692021-09-23 19:56:24 -04003109 @Override
Charlie Anderson8ad91442023-01-09 13:55:59 -05003110 public boolean canUseMultipleShadesForPopup() {
Brian Isganitisa85ae692021-09-23 19:56:24 -04003111 return getTopOpenViewWithType(this, TYPE_FOLDER) == null
3112 && getStateManager().getState() != LauncherState.ALL_APPS;
Sunny Goyal831212e2021-05-14 14:24:09 -07003113 }
3114
Sunny Goyalb5181c82021-03-10 07:39:12 +00003115 @Override
3116 protected void collectStateHandlers(List<StateHandler> out) {
3117 out.add(getAllAppsController());
3118 out.add(getWorkspace());
Andrew Sappersteinabef55a2016-06-19 12:49:00 -07003119 }
3120
Sunny Goyal210e1742019-10-17 12:05:38 -07003121 public TouchController[] createTouchControllers() {
3122 return new TouchController[] {getDragController(), new AllAppsSwipeController(this)};
3123 }
3124
Sunny Goyal1eb11242022-09-09 17:14:45 -07003125 public void onDragLayerHierarchyChanged() {
3126 updateDisallowBack();
3127 }
3128
Vinit Nayak65460402023-08-11 15:40:07 -07003129 protected void addBackAnimationCallback(BackPressHandler callback) {
3130 mBackPressedHandlers.add(callback);
3131 }
3132
3133 protected void removeBackAnimationCallback(BackPressHandler callback) {
3134 mBackPressedHandlers.remove(callback);
3135 }
3136
Sunny Goyal1eb11242022-09-09 17:14:45 -07003137 private void updateDisallowBack() {
Sukesh Ram3f2338a2023-08-28 18:31:54 +00003138 if (DESKTOP_MODE_SUPPORTED) {
Ats Jenk8121e0d2022-12-01 11:34:43 -08003139 // Do not disable back in launcher when prototype behavior is enabled
3140 return;
3141 }
Sunny Goyal1eb11242022-09-09 17:14:45 -07003142 LauncherRootView rv = getRootView();
3143 if (rv != null) {
Vinit Nayak65460402023-08-11 15:40:07 -07003144 boolean isSplitSelectionEnabled = isSplitSelectionEnabled();
Sunny Goyal1eb11242022-09-09 17:14:45 -07003145 boolean disableBack = getStateManager().getState() == NORMAL
Vinit Nayak65460402023-08-11 15:40:07 -07003146 && AbstractFloatingView.getTopOpenView(this) == null
3147 && !isSplitSelectionEnabled;
Sunny Goyal1eb11242022-09-09 17:14:45 -07003148 rv.setDisallowBackGesture(disableBack);
3149 }
3150 }
Sunny Goyal210e1742019-10-17 12:05:38 -07003151
Vinit Nayak65460402023-08-11 15:40:07 -07003152 /** To be overridden by subclasses */
3153 protected boolean isSplitSelectionEnabled() {
3154 // Overridden
3155 return false;
3156 }
3157
Vinit Nayakf9b585b2019-07-10 14:25:32 -07003158 @Override
3159 public void returnToHomescreen() {
3160 super.returnToHomescreen();
3161 getStateManager().goToState(LauncherState.NORMAL);
3162 }
3163
Sebastian Franco4080fdd2023-09-19 14:17:23 -07003164 public void closeOpenViews() {
Andy Wickham65ced1b2020-03-07 02:14:19 +00003165 closeOpenViews(true);
3166 }
3167
3168 protected void closeOpenViews(boolean animate) {
3169 AbstractFloatingView.closeAllOpenViews(this, animate);
3170 }
3171
Sunny Goyal384b5782021-02-09 22:50:02 -08003172 protected LauncherAccessibilityDelegate createAccessibilityDelegate() {
3173 return new LauncherAccessibilityDelegate(this);
3174 }
Sunny Goyalf2393f12020-04-01 20:13:12 -07003175
Schneider Victor-tulias7cd0ae32023-03-21 11:46:18 -07003176 /** Enables/disabled the hotseat prediction icon long press edu for testing. */
3177 @VisibleForTesting
3178 public void enableHotseatEdu(boolean enable) {}
3179
Sunny Goyal210e1742019-10-17 12:05:38 -07003180
Sunny Goyal3dce5f32017-10-05 11:40:05 -07003181 /**
Sunny Goyalab770a12018-11-14 15:17:26 -08003182 * Just a wrapper around the type cast to allow easier tracking of calls.
3183 */
3184 public static <T extends Launcher> T cast(ActivityContext activityContext) {
3185 return (T) activityContext;
3186 }
3187
Sunny Goyalb65d7662021-03-07 15:09:11 -08003188 public boolean supportsAdaptiveIconAnimation(View clickedView) {
3189 return false;
3190 }
3191
Schneider Victor-tulias9b6babf2022-03-24 14:47:32 -07003192 /**
3193 * Animates Launcher elements during a transition to the All Apps page.
3194 *
3195 * @param progress Transition progress from 0 to 1; where 0 => home and 1 => all apps.
3196 */
3197 public void onAllAppsTransition(float progress) {
3198 // No-Op
3199 }
3200
3201 /**
3202 * Animates Launcher elements during a transition to the Widgets pages.
3203 *
3204 * @param progress Transition progress from 0 to 1; where 0 => home and 1 => widgets.
3205 */
3206 public void onWidgetsTransition(float progress) {
Alex Chau3d2c0622022-09-01 21:28:14 +01003207 float scale = Utilities.mapToRange(progress, 0f, 1f, 1f,
3208 mDeviceProfile.bottomSheetWorkspaceScale, EMPHASIZED);
3209 WORKSPACE_WIDGET_SCALE.set(getWorkspace(), scale);
3210 HOTSEAT_WIDGET_SCALE.set(getHotseat(), scale);
Schneider Victor-tulias9b6babf2022-03-24 14:47:32 -07003211 }
3212
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08003213 private static class NonConfigInstance {
3214 public Configuration config;
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08003215 }
thiruramc96873c2021-02-11 15:13:47 -08003216
Schneider Victor-tulias789a6a92022-03-04 12:06:09 -08003217 /** Pauses view updates that should not be run during the app launch animation. */
3218 public void pauseExpensiveViewUpdates() {
3219 // Pause page indicator animations as they lead to layer trashing.
Shikha Malhotrae957b602022-04-11 07:57:18 +00003220 getWorkspace().getPageIndicator().pauseAnimations();
Jon Miranda46ecc0c2022-06-02 11:34:15 -07003221
3222 getWorkspace().mapOverItems((info, view) -> {
3223 if (view instanceof LauncherAppWidgetHostView) {
3224 ((LauncherAppWidgetHostView) view).beginDeferringUpdates();
3225 }
3226 return false; // Return false to continue iterating through all the items.
3227 });
Schneider Victor-tulias789a6a92022-03-04 12:06:09 -08003228 }
3229
3230 /** Resumes view updates at the end of the app launch animation. */
3231 public void resumeExpensiveViewUpdates() {
Shikha Malhotrae957b602022-04-11 07:57:18 +00003232 getWorkspace().getPageIndicator().skipAnimationsToEnd();
Shikha Malhotra0f2e1b62022-03-27 21:02:21 +00003233
Jon Miranda46ecc0c2022-06-02 11:34:15 -07003234 getWorkspace().mapOverItems((info, view) -> {
3235 if (view instanceof LauncherAppWidgetHostView) {
3236 ((LauncherAppWidgetHostView) view).endDeferringUpdates();
3237 }
3238 return false; // Return false to continue iterating through all the items.
3239 });
3240 }
Ats Jenkca009e42023-01-06 09:52:40 -08003241
3242 /**
3243 * Returns {@code true} if there are visible tasks with windowing mode set to
3244 * {@link android.app.WindowConfiguration#WINDOWING_MODE_FREEFORM}
3245 */
3246 public boolean areFreeformTasksVisible() {
3247 return false; // Base launcher does not track freeform tasks
3248 }
Brian Isganitisf54c6fa2023-07-11 12:47:08 -04003249
Sebastian Franco8a3de212023-09-05 18:54:01 -07003250 // Getters and Setters
3251
3252 private void setWorkspaceLoading(boolean value) {
3253 mWorkspaceLoading = value;
3254 }
3255
3256 public boolean isWorkspaceLocked() {
3257 return mWorkspaceLoading || mPendingRequestArgs != null;
3258 }
3259
3260 public boolean isWorkspaceLoading() {
3261 return mWorkspaceLoading;
3262 }
3263
Brian Isganitisf54c6fa2023-07-11 12:47:08 -04003264 @Override
Sebastian Franco8a3de212023-09-05 18:54:01 -07003265 public boolean isBindingItems() {
3266 return mWorkspaceLoading;
3267 }
3268
3269 /**
3270 * Returns true if a touch interaction is in progress
3271 */
3272 public boolean isTouchInProgress() {
3273 return mTouchInProgress;
3274 }
3275
3276 public boolean isDraggingEnabled() {
3277 // We prevent dragging when we are loading the workspace as it is possible to pick up a view
3278 // that is subsequently removed from the workspace in startBinding().
3279 return !isWorkspaceLoading();
3280 }
3281
3282 public void setWaitingForResult(PendingRequestArgs args) {
3283 mPendingRequestArgs = args;
3284 }
3285
3286 /**
3287 * Call this after onCreate to set or clear overlay.
3288 */
3289 @Override
3290 public void setLauncherOverlay(LauncherOverlay overlay) {
3291 mWorkspace.setLauncherOverlay(overlay);
3292 }
3293
3294 public boolean setLauncherCallbacks(LauncherCallbacks callbacks) {
3295 mLauncherCallbacks = callbacks;
3296 return true;
3297 }
3298
3299 /**
3300 * Persistent callback which notifies when an activity launch is deferred because the activity
3301 * was not yet resumed.
3302 */
3303 public void setOnDeferredActivityLaunchCallback(Runnable callback) {
3304 mOnDeferredActivityLaunchCallback = callback;
3305 }
3306
3307 /**
3308 * Sets the next pages to bind synchronously on next bind.
3309 * @param pages should not be null.
3310 */
3311 public void setPagesToBindSynchronously(@NonNull IntSet pages) {
3312 mPagesToBindSynchronously = pages;
3313 }
3314
3315 public OnboardingPrefs<? extends Launcher> getOnboardingPrefs() {
3316 return mOnboardingPrefs;
3317 }
3318
3319 @Override
3320 public CellPosMapper getCellPosMapper() {
3321 return mCellPosMapper;
3322 }
3323
3324 public RotationHelper getRotationHelper() {
3325 return mRotationHelper;
3326 }
3327
3328 public ViewGroupFocusHelper getFocusHandler() {
3329 return mFocusHandler;
3330 }
3331
3332 @Override
3333 public StateManager<LauncherState> getStateManager() {
3334 return mStateManager;
3335 }
3336
3337 @NonNull
3338 @Override
3339 public PopupDataProvider getPopupDataProvider() {
3340 return mPopupDataProvider;
3341 }
3342
3343 @Override
3344 public DotInfo getDotInfoForItem(ItemInfo info) {
3345 return mPopupDataProvider.getDotInfoForItem(info);
3346 }
3347
3348 public LauncherOverlayManager getOverlayManager() {
3349 return mOverlayManager;
3350 }
3351
3352 public AllAppsTransitionController getAllAppsController() {
3353 return mAllAppsController;
3354 }
3355
3356 @Override
3357 public DragLayer getDragLayer() {
3358 return mDragLayer;
3359 }
3360
3361 @Override
3362 public ActivityAllAppsContainerView<Launcher> getAppsView() {
3363 return mAppsView;
3364 }
3365
3366 public Workspace<?> getWorkspace() {
3367 return mWorkspace;
3368 }
3369
3370 public Hotseat getHotseat() {
3371 return mHotseat;
3372 }
3373
3374 public <T extends View> T getOverviewPanel() {
3375 return (T) mOverviewPanel;
3376 }
3377
3378 public DropTargetBar getDropTargetBar() {
3379 return mDropTargetBar;
3380 }
3381
3382 @Override
3383 public ScrimView getScrimView() {
3384 return mScrimView;
3385 }
3386
3387 public LauncherWidgetHolder getAppWidgetHolder() {
3388 return mAppWidgetHolder;
3389 }
3390
3391 public LauncherModel getModel() {
3392 return mModel;
3393 }
3394
3395 /**
3396 * Returns the ModelWriter writer, make sure to call the function every time you want to use it.
3397 */
3398 public ModelWriter getModelWriter() {
3399 return mModelWriter;
3400 }
3401
3402 @Override
3403 public SharedPreferences getSharedPrefs() {
3404 return mSharedPrefs;
3405 }
3406
3407 @Override
3408 public SharedPreferences getDevicePrefs() {
3409 return LauncherPrefs.getDevicePrefs(this);
3410 }
3411
3412 public int getOrientation() {
3413 return mOldConfig.orientation;
3414 }
3415
3416 public BaseSearchConfig getSearchConfig() {
3417 return mBaseSearchConfig;
3418 }
3419
3420 /**
3421 * Returns the CellLayout of the specified container at the specified screen.
3422 *
3423 * @param screenId must be presenterPos and not modelPos.
3424 */
3425 public CellLayout getCellLayout(int container, int screenId) {
3426 return (container == LauncherSettings.Favorites.CONTAINER_HOTSEAT)
3427 ? mHotseat : mWorkspace.getScreenWithId(screenId);
3428 }
3429
3430 @Override
3431 public StringCache getStringCache() {
3432 return mStringCache;
3433 }
3434
3435 /**
3436 * Returns target rectangle for anchoring a popup menu.
3437 */
3438 protected RectF getPopupTarget(float x, float y) {
3439 float halfSize = getResources().getDimension(R.dimen.options_menu_thumb_size) / 2;
3440 if (x < 0 || y < 0) {
3441 x = mDragLayer.getWidth() / 2;
3442 y = mDragLayer.getHeight() / 2;
3443 }
3444 return new RectF(x - halfSize, y - halfSize, x + halfSize, y + halfSize);
3445 }
3446
3447 public Stream<SystemShortcut.Factory> getSupportedShortcuts() {
3448 return Stream.of(APP_INFO, WIDGETS, INSTALL);
3449 }
3450
3451 /**
3452 * @see LauncherState#getOverviewScaleAndOffset(Launcher)
3453 */
3454 public float[] getNormalOverviewScaleAndOffset() {
3455 return new float[] {NO_SCALE, NO_OFFSET};
Brian Isganitisf54c6fa2023-07-11 12:47:08 -04003456 }
Jeremy Sim94fd07e2023-04-19 20:56:49 -07003457
3458 /**
3459 * Handles an app pair launch; overridden in
3460 * {@link com.android.launcher3.uioverrides.QuickstepLauncher}
3461 */
3462 public void launchAppPair(WorkspaceItemInfo app1, WorkspaceItemInfo app2) {
3463 // Overridden
3464 }
Sunny Goyal0ee66472023-08-17 16:19:22 -07003465
fbaronc0e687b2023-10-04 12:11:20 -07003466 public boolean getIsFirstPagePinnedItemEnabled() {
3467 return mIsFirstPagePinnedItemEnabled;
3468 }
3469
Sunny Goyal0ee66472023-08-17 16:19:22 -07003470 /**
3471 * Returns the animation coordinator for playing one-off animations
3472 */
3473 public CannedAnimationCoordinator getAnimationCoordinator() {
3474 return mAnimationCoordinator;
3475 }
Sebastian Franco8a3de212023-09-05 18:54:01 -07003476
3477 @Override
3478 public View.OnLongClickListener getAllAppsItemLongClickListener() {
3479 return ItemLongClickListener.INSTANCE_ALL_APPS;
3480 }
3481
3482 @Override
3483 public StatsLogManager getStatsLogManager() {
3484 return super.getStatsLogManager().withDefaultInstanceId(mAllAppsSessionLogId);
3485 }
3486
3487 /**
3488 * Returns the current popup for testing, if any.
3489 */
3490 @VisibleForTesting
3491 @Nullable
3492 public ArrowPopup<?> getOptionsPopup() {
3493 return findViewById(R.id.popup_container);
3494 }
3495
3496 // End of Getters and Setters
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003497}