blob: c1473d7eec5b193889484ffeb6965860a7e09a3a [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;
Alex Chau0c4e11b2022-07-08 18:41:36 +010031import static com.android.launcher3.LauncherAnimUtils.HOTSEAT_SCALE_PROPERTY_FACTORY;
32import static com.android.launcher3.LauncherAnimUtils.SCALE_INDEX_WIDGET_TRANSITION;
Sunny Goyal4c7f2152017-10-17 17:17:16 -070033import static com.android.launcher3.LauncherAnimUtils.SPRING_LOADED_EXIT_DELAY;
Alex Chau0c4e11b2022-07-08 18:41:36 +010034import static com.android.launcher3.LauncherAnimUtils.WORKSPACE_SCALE_PROPERTY_FACTORY;
Sunny Goyal669b71f2023-01-27 14:37:07 -080035import static com.android.launcher3.LauncherSettings.Favorites.CONTAINER_DESKTOP;
Jon Mirandac4a99bf2021-11-04 16:53:45 -070036import static com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_APPLICATION;
Sunny Goyal3e3f44c2017-10-23 17:14:52 -070037import static com.android.launcher3.LauncherState.ALL_APPS;
Charlie Anderson438d4052023-04-25 14:38:57 -040038import static com.android.launcher3.LauncherState.EDIT_MODE;
Sunny Goyal8f965462020-04-23 19:00:36 -070039import static com.android.launcher3.LauncherState.FLAG_MULTI_PAGE;
40import static com.android.launcher3.LauncherState.FLAG_NON_INTERACTIVE;
Sunny Goyal3e3f44c2017-10-23 17:14:52 -070041import static com.android.launcher3.LauncherState.NORMAL;
Sunny Goyalf2393f12020-04-01 20:13:12 -070042import static com.android.launcher3.LauncherState.NO_OFFSET;
43import static com.android.launcher3.LauncherState.NO_SCALE;
Sunny Goyal8f965462020-04-23 19:00:36 -070044import static com.android.launcher3.LauncherState.SPRING_LOADED;
Sunny Goyalb1d7de22019-09-06 10:36:54 -070045import static com.android.launcher3.Utilities.postAsyncCallback;
Sunny Goyal384b5782021-02-09 22:50:02 -080046import static com.android.launcher3.accessibility.LauncherAccessibilityDelegate.getSupportedActions;
Sebastián Franco1f4d56c2023-08-08 03:29:10 +000047import static com.android.launcher3.config.FeatureFlags.FOLDABLE_SINGLE_PAGE;
Charlie Anderson438d4052023-04-25 14:38:57 -040048import static com.android.launcher3.config.FeatureFlags.MULTI_SELECT_EDIT_MODE;
Federico Barona1845112022-10-20 21:11:58 -070049import static com.android.launcher3.config.FeatureFlags.SHOW_DOT_PAGINATION;
Thiru Ramasamy5fbac632022-01-28 15:05:36 -080050import static com.android.launcher3.logging.StatsLogManager.EventEnum;
Hyunyoung Song801f81f2020-06-19 02:58:53 -070051import static com.android.launcher3.logging.StatsLogManager.LAUNCHER_STATE_BACKGROUND;
Hyunyoung Song95786e02020-09-15 00:34:10 -070052import static com.android.launcher3.logging.StatsLogManager.LAUNCHER_STATE_HOME;
thiruramc96873c2021-02-11 15:13:47 -080053import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ALLAPPS_ENTRY;
thiruram9f53d612021-02-24 10:54:01 -080054import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ALLAPPS_ENTRY_WITH_DEVICE_SEARCH;
thiruramc96873c2021-02-11 15:13:47 -080055import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ALLAPPS_EXIT;
Hyunyoung Song801f81f2020-06-19 02:58:53 -070056import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ONRESUME;
57import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ONSTOP;
Sunny Goyal82379182022-11-02 18:58:49 -070058import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_SWIPELEFT;
59import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_SWIPERIGHT;
Yogisha Dixit4ff5ee32021-05-04 14:58:34 +010060import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_WIDGET_RECONFIGURED;
Fengjiang Li5a36c172023-04-13 18:18:27 +000061import static com.android.launcher3.logging.StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_ACTIVITY_ON_CREATE;
62import static com.android.launcher3.logging.StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_TOTAL_DURATION;
63import static com.android.launcher3.logging.StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_VIEW_INFLATION;
64import static com.android.launcher3.logging.StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_ASYNC;
65import static com.android.launcher3.logging.StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_SYNC;
66import static com.android.launcher3.logging.StatsLogManager.StatsLatencyLogger.LatencyType.COLD;
67import static com.android.launcher3.logging.StatsLogManager.StatsLatencyLogger.LatencyType.COLD_DEVICE_REBOOTING;
68import static com.android.launcher3.logging.StatsLogManager.StatsLatencyLogger.LatencyType.WARM;
Sunny Goyal60e68c92020-08-12 13:59:27 -070069import static com.android.launcher3.model.ItemInstallQueue.FLAG_ACTIVITY_PAUSED;
70import static com.android.launcher3.model.ItemInstallQueue.FLAG_DRAG_AND_DROP;
fbaron30d9e3f2023-08-03 17:03:59 -070071import static com.android.launcher3.model.data.LauncherAppWidgetInfo.CUSTOM_WIDGET_ID;
Sunny Goyal3a1eadd2019-10-23 17:44:27 -070072import static com.android.launcher3.popup.SystemShortcut.APP_INFO;
Sunny Goyal3a1eadd2019-10-23 17:44:27 -070073import static com.android.launcher3.popup.SystemShortcut.INSTALL;
74import static com.android.launcher3.popup.SystemShortcut.WIDGETS;
Sunny Goyal8f965462020-04-23 19:00:36 -070075import static com.android.launcher3.states.RotationHelper.REQUEST_LOCK;
Sunny Goyalbe8c3402019-05-22 15:17:52 -070076import static com.android.launcher3.states.RotationHelper.REQUEST_NONE;
Jeremy Sim7cf0dd92023-03-24 22:39:45 -070077import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
Jon Mirandac4a99bf2021-11-04 16:53:45 -070078import static com.android.launcher3.util.ItemInfoMatcher.forFolderMatch;
Sunny Goyal326403e2017-10-02 12:45:10 -070079
Gilles Debunnedd6c9922010-10-25 11:23:41 -070080import android.animation.Animator;
Sunny Goyal6001ea22018-05-10 16:31:00 -070081import android.animation.AnimatorListenerAdapter;
Gilles Debunnedd6c9922010-10-25 11:23:41 -070082import android.animation.AnimatorSet;
Gilles Debunnedd6c9922010-10-25 11:23:41 -070083import android.animation.ValueAnimator;
Adam Cohen0b395352014-06-09 22:54:36 +000084import android.annotation.TargetApi;
Tony Wickhame78a70b2021-03-29 16:45:59 -070085import android.app.Notification;
86import android.app.NotificationChannel;
87import android.app.NotificationManager;
88import android.app.PendingIntent;
Adam Cohen0cf2a7c2011-11-08 15:07:01 -080089import android.appwidget.AppWidgetHostView;
Michael Jurkaaf442092010-06-10 17:01:57 -070090import android.appwidget.AppWidgetManager;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080091import android.content.ActivityNotFoundException;
Michael Jurkae326f182011-11-21 14:05:46 -080092import android.content.ComponentCallbacks2;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080093import android.content.Context;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080094import android.content.Intent;
Adam Cohen173f7112015-03-27 15:14:00 -070095import android.content.IntentSender;
Winson Chung82f55532011-08-09 14:14:23 -070096import android.content.SharedPreferences;
Sunny Goyalf8d56fc2018-01-31 15:18:11 -080097import android.content.res.Configuration;
Adam Cohen3f9c9712014-10-31 11:48:25 -070098import android.database.sqlite.SQLiteDatabase;
Sunny Goyal5cd1b192023-04-06 22:33:11 +000099import android.graphics.Color;
Tony Wickham1906cc32021-02-11 11:55:24 -0800100import android.graphics.Rect;
Sunny Goyal831212e2021-05-14 14:24:09 -0700101import android.graphics.RectF;
Adam Cohen0f668f32014-09-08 19:54:17 +0200102import android.os.Build;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800103import android.os.Bundle;
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -0700104import android.os.Parcelable;
Winson Chunga2413752012-04-03 14:22:34 -0700105import android.os.StrictMode;
Riddle Hsu979da642020-09-22 21:52:40 +0800106import android.os.SystemClock;
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -0700107import android.os.Trace;
Jon Mirandac4a99bf2021-11-04 16:53:45 -0700108import android.os.UserHandle;
Michael Jurkaa33411c2012-06-14 16:18:21 -0700109import android.text.TextUtils;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800110import android.text.method.TextKeyListener;
Federico Baron7539d762022-09-29 09:47:04 -0700111import android.util.AttributeSet;
Alex Chau0c4e11b2022-07-08 18:41:36 +0100112import android.util.FloatProperty;
Joe Onorato7c312c12009-08-13 21:36:53 -0700113import android.util.Log;
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -0700114import android.util.SparseArray;
Adam Cohen96d30a12013-07-16 18:13:21 -0700115import android.view.KeyEvent;
Sunny Goyal66b24572016-09-21 15:57:55 -0700116import android.view.KeyboardShortcutGroup;
117import android.view.KeyboardShortcutInfo;
Sunny Goyal9b29ca52017-02-17 10:39:44 -0800118import android.view.LayoutInflater;
Adam Cohen96d30a12013-07-16 18:13:21 -0700119import android.view.Menu;
vadimt9af34a72020-01-21 11:19:13 -0800120import android.view.MotionEvent;
Adam Cohen96d30a12013-07-16 18:13:21 -0700121import android.view.View;
Adam Cohen96d30a12013-07-16 18:13:21 -0700122import android.view.ViewGroup;
Fengjiang Li5a36c172023-04-13 18:18:27 +0000123import android.view.ViewTreeObserver;
Sunny Goyal7b8d63f2022-04-14 16:37:32 -0700124import android.view.ViewTreeObserver.OnPreDrawListener;
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -0700125import android.view.WindowManager.LayoutParams;
Svetoslav Ganov815ba2d2011-01-07 14:55:17 -0800126import android.view.accessibility.AccessibilityEvent;
Sunny Goyal5a1f53b2015-05-27 10:24:24 -0700127import android.view.animation.OvershootInterpolator;
Fengjiang Lib7860bd2023-03-15 10:50:50 -0700128import android.window.BackEvent;
129import android.window.OnBackAnimationCallback;
Sunny Goyala1d1bf32015-06-26 13:24:53 -0700130
Sunny Goyal35e7d382020-05-08 13:37:58 -0700131import androidx.annotation.CallSuper;
Andras Kloczl55edfe52021-05-14 12:21:30 +0200132import androidx.annotation.NonNull;
Sunny Goyal11a50742019-08-07 09:24:26 -0700133import androidx.annotation.Nullable;
Fengjiang Lid0c23592023-04-20 16:42:25 -0700134import androidx.annotation.RequiresApi;
Pinyao Tingc9074272019-11-11 11:51:44 -0800135import androidx.annotation.StringRes;
Anushree Ganjam97434ee2023-05-18 22:03:16 +0000136import androidx.annotation.UiThread;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700137import androidx.annotation.VisibleForTesting;
Sunny Goyal11a50742019-08-07 09:24:26 -0700138
Sunny Goyal651077b2014-06-30 14:15:31 -0700139import com.android.launcher3.DropTarget.DragObject;
Schneider Victor-tuliasbdb0dd82021-11-03 16:26:41 -0700140import com.android.launcher3.accessibility.BaseAccessibilityDelegate.LauncherAction;
Sunny Goyalae502842016-06-17 08:43:56 -0700141import com.android.launcher3.accessibility.LauncherAccessibilityDelegate;
Brian Isganitis1664c9f2022-01-14 23:15:47 -0500142import com.android.launcher3.allapps.ActivityAllAppsContainerView;
Jon Mirandaf58db152022-06-02 16:06:37 -0700143import com.android.launcher3.allapps.AllAppsRecyclerView;
vadimtd4c90e12019-06-04 13:59:43 -0700144import com.android.launcher3.allapps.AllAppsStore;
Hyunyoung Song645764e2016-06-06 14:19:02 -0700145import com.android.launcher3.allapps.AllAppsTransitionController;
Becky Qiu4ed3dfc2022-10-19 16:58:22 -0700146import com.android.launcher3.allapps.BaseSearchConfig;
Sunny Goyal7ede6112017-12-05 15:11:21 -0800147import com.android.launcher3.allapps.DiscoveryBounce;
Sunny Goyalf0b6db72018-08-13 16:10:14 -0700148import com.android.launcher3.anim.PropertyListBuilder;
Jeremy Sim94fd07e2023-04-19 20:56:49 -0700149import com.android.launcher3.apppairs.AppPairIcon;
Sunny Goyal669b71f2023-01-27 14:37:07 -0800150import com.android.launcher3.celllayout.CellPosMapper;
151import com.android.launcher3.celllayout.CellPosMapper.CellPos;
Sebastian Franco09589322022-11-02 15:25:58 -0700152import com.android.launcher3.celllayout.CellPosMapper.TwoPanelCellPosMapper;
Sunny Goyal8f965462020-04-23 19:00:36 -0700153import com.android.launcher3.compat.AccessibilityManagerCompat;
Tony Wickhame0c33232016-02-08 11:37:04 -0800154import com.android.launcher3.config.FeatureFlags;
vadimt00d42552018-12-11 17:59:36 -0800155import com.android.launcher3.dot.DotInfo;
Vadim Tryshevfedca432015-08-19 17:55:02 -0700156import com.android.launcher3.dragndrop.DragController;
157import com.android.launcher3.dragndrop.DragLayer;
158import com.android.launcher3.dragndrop.DragView;
Sunny Goyal59969372021-05-06 12:11:44 -0700159import com.android.launcher3.dragndrop.LauncherDragController;
Federico Baron8bf1bca2022-09-27 16:19:11 -0700160import com.android.launcher3.folder.Folder;
Sunny Goyal11a50742019-08-07 09:24:26 -0700161import com.android.launcher3.folder.FolderGridOrganizer;
Sunny Goyal26119432016-02-18 22:09:23 +0000162import com.android.launcher3.folder.FolderIcon;
Sunny Goyalf840f102018-09-21 14:41:05 -0700163import com.android.launcher3.icons.IconCache;
Sunny Goyal3333b0c2016-05-09 20:43:21 -0700164import com.android.launcher3.keyboard.ViewGroupFocusHelper;
Hyunyoung Song801f81f2020-06-19 02:58:53 -0700165import com.android.launcher3.logger.LauncherAtom;
Thiru Ramasamy5fbac632022-01-28 15:05:36 -0800166import com.android.launcher3.logger.LauncherAtom.ContainerInfo;
167import com.android.launcher3.logger.LauncherAtom.WorkspaceContainer;
Sunny Goyala7ce1662016-05-31 15:01:35 -0700168import com.android.launcher3.logging.FileLog;
thiruramc96873c2021-02-11 15:13:47 -0800169import com.android.launcher3.logging.InstanceId;
170import com.android.launcher3.logging.InstanceIdSequence;
Fengjiang Li5a36c172023-04-13 18:18:27 +0000171import com.android.launcher3.logging.StartupLatencyLogger;
Hyunyoung Song801f81f2020-06-19 02:58:53 -0700172import com.android.launcher3.logging.StatsLogManager;
Sunny Goyal87dcde62019-07-17 20:35:56 -0700173import com.android.launcher3.model.BgDataModel.Callbacks;
Sunny Goyal60e68c92020-08-12 13:59:27 -0700174import com.android.launcher3.model.ItemInstallQueue;
Sunny Goyala535ae42017-02-27 10:07:13 -0800175import com.android.launcher3.model.ModelWriter;
kholoud mohamedc76b2032021-12-20 16:47:38 +0000176import com.android.launcher3.model.StringCache;
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -0700177import com.android.launcher3.model.WidgetsModel;
Sunny Goyale396abf2020-04-06 15:11:17 -0700178import com.android.launcher3.model.data.AppInfo;
179import com.android.launcher3.model.data.FolderInfo;
180import com.android.launcher3.model.data.ItemInfo;
181import com.android.launcher3.model.data.LauncherAppWidgetInfo;
Sunny Goyale396abf2020-04-06 15:11:17 -0700182import com.android.launcher3.model.data.WorkspaceItemInfo;
Sunny Goyala535ae42017-02-27 10:07:13 -0800183import com.android.launcher3.notification.NotificationListener;
Federico Baron7539d762022-09-29 09:47:04 -0700184import com.android.launcher3.pageindicators.WorkspacePageIndicator;
Sunny Goyale7b00122019-10-02 16:13:34 -0700185import com.android.launcher3.pm.PinRequestHelper;
Brian Isganitis149dbcb2021-11-08 18:12:38 -0500186import com.android.launcher3.popup.ArrowPopup;
Tony Wickham540913e2017-01-23 11:47:51 -0800187import com.android.launcher3.popup.PopupContainerWithArrow;
Sunny Goyala535ae42017-02-27 10:07:13 -0800188import com.android.launcher3.popup.PopupDataProvider;
Sunny Goyal3a1eadd2019-10-23 17:44:27 -0700189import com.android.launcher3.popup.SystemShortcut;
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700190import com.android.launcher3.qsb.QsbContainerView;
Sunny Goyal35e7d382020-05-08 13:37:58 -0700191import com.android.launcher3.statemanager.StateManager;
192import com.android.launcher3.statemanager.StateManager.StateHandler;
Sunny Goyal35e7d382020-05-08 13:37:58 -0700193import com.android.launcher3.statemanager.StatefulActivity;
Sunny Goyal623eddd2018-03-02 12:24:41 -0800194import com.android.launcher3.states.RotationHelper;
vadimt9af34a72020-01-21 11:19:13 -0800195import com.android.launcher3.testing.TestLogging;
vadimtf6ef8792022-07-26 13:54:31 -0700196import com.android.launcher3.testing.shared.TestProtocol;
Sunny Goyal210e1742019-10-17 12:05:38 -0700197import com.android.launcher3.touch.AllAppsSwipeController;
Brian Isganitisf54c6fa2023-07-11 12:47:08 -0400198import com.android.launcher3.touch.ItemLongClickListener;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700199import com.android.launcher3.uioverrides.plugins.PluginManagerWrapper;
Sunny Goyal2100c782016-08-22 16:00:03 -0700200import com.android.launcher3.util.ActivityResultInfo;
Sunny Goyale84c5b82019-09-26 17:05:31 -0700201import com.android.launcher3.util.ActivityTracker;
Vinit Nayak65460402023-08-11 15:40:07 -0700202import com.android.launcher3.util.BackPressHandler;
Sukesh Ram3f2338a2023-08-28 18:31:54 +0000203import com.android.launcher3.util.CannedAnimationCoordinator;
Winson Chung6b1c73f2015-06-18 11:38:42 -0700204import com.android.launcher3.util.ComponentKey;
Sunny Goyalefb7e842018-10-04 15:11:00 -0700205import com.android.launcher3.util.IntArray;
Andras Kloczl55edfe52021-05-14 12:21:30 +0200206import com.android.launcher3.util.IntSet;
Fengjiang Li5a36c172023-04-13 18:18:27 +0000207import com.android.launcher3.util.LockedUserState;
Tony Wickham133cd542020-04-08 17:48:41 -0700208import com.android.launcher3.util.OnboardingPrefs;
Tony Wickham010d2552017-01-20 08:15:28 -0800209import com.android.launcher3.util.PackageUserKey;
Sunny Goyal2100c782016-08-22 16:00:03 -0700210import com.android.launcher3.util.PendingRequestArgs;
Anushree Ganjam97434ee2023-05-18 22:03:16 +0000211import com.android.launcher3.util.Preconditions;
Sunny Goyal4a48a982021-06-17 15:15:46 -0700212import com.android.launcher3.util.RunnableList;
Sunny Goyala992ac92023-01-10 17:50:32 -0800213import com.android.launcher3.util.ScreenOnTracker;
214import com.android.launcher3.util.ScreenOnTracker.ScreenOnListener;
Sunny Goyal8392c822017-06-20 10:03:56 -0700215import com.android.launcher3.util.SystemUiController;
Mario Bertschlera6936942017-05-31 14:48:19 -0700216import com.android.launcher3.util.Themes;
Adam Cohen091440a2015-03-18 14:16:05 -0700217import com.android.launcher3.util.Thunk;
Sunny Goyal210e1742019-10-17 12:05:38 -0700218import com.android.launcher3.util.TouchController;
Sunny Goyalfca6bc92017-09-28 16:28:34 -0700219import com.android.launcher3.util.TraceHelper;
Sunny Goyal527c7d32015-08-28 15:19:36 -0700220import com.android.launcher3.util.ViewOnDrawExecutor;
Sunny Goyalab770a12018-11-14 15:17:26 -0800221import com.android.launcher3.views.ActivityContext;
Xiaowen Lei3c0f30a2023-04-12 16:59:45 -0700222import com.android.launcher3.views.ComposeInitializer;
Jon Mirandaf58db152022-06-02 16:06:37 -0700223import com.android.launcher3.views.FloatingIconView;
Sunny Goyal30ac97d2020-06-24 23:47:46 -0700224import com.android.launcher3.views.FloatingSurfaceView;
Sunny Goyal7c7be8c2018-03-07 19:58:07 -0800225import com.android.launcher3.views.OptionsPopupView;
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400226import com.android.launcher3.views.ScrimView;
Sunny Goyal29947f02017-12-18 13:49:44 -0800227import com.android.launcher3.widget.LauncherAppWidgetHostView;
Yogisha Dixit741fae92021-02-22 14:03:44 +0000228import com.android.launcher3.widget.LauncherAppWidgetProviderInfo;
Sihua Ma8bbfcb62022-11-08 16:46:07 -0800229import com.android.launcher3.widget.LauncherWidgetHolder;
Sunny Goyal782f0c92017-01-19 10:27:54 -0800230import com.android.launcher3.widget.PendingAddShortcutInfo;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700231import com.android.launcher3.widget.PendingAddWidgetInfo;
Sunny Goyal29947f02017-12-18 13:49:44 -0800232import com.android.launcher3.widget.PendingAppWidgetHostView;
Sunny Goyal04a324a2017-01-20 21:08:59 -0800233import com.android.launcher3.widget.WidgetAddFlowHandler;
Sunny Goyal337c81f2019-12-10 12:19:13 -0800234import com.android.launcher3.widget.WidgetManagerHelper;
Pinyao Tingc7a6c292019-08-26 14:36:02 -0700235import com.android.launcher3.widget.custom.CustomWidgetManager;
Steven Ng2f5648a2021-02-08 17:18:25 +0000236import com.android.launcher3.widget.model.WidgetsListBaseEntry;
237import com.android.launcher3.widget.picker.WidgetsFullSheet;
Sunny Goyal80a071b2021-12-27 13:30:08 +0530238import com.android.systemui.plugins.LauncherOverlayPlugin;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700239import com.android.systemui.plugins.PluginListener;
240import com.android.systemui.plugins.shared.LauncherExterns;
241import com.android.systemui.plugins.shared.LauncherOverlayManager;
242import com.android.systemui.plugins.shared.LauncherOverlayManager.LauncherOverlay;
Adam Cohen6c5891a2014-07-09 23:53:15 -0700243
Adam Cohen16d7ffc2011-10-05 17:49:14 -0700244import java.io.FileDescriptor;
Adam Cohen16d7ffc2011-10-05 17:49:14 -0700245import java.io.PrintWriter;
Adam Cohenc0dcf592011-06-01 15:30:43 -0700246import java.util.ArrayList;
Winson Chungf0c6ae02012-03-21 16:10:31 -0700247import java.util.Collection;
Jon Mirandac4a99bf2021-11-04 16:53:45 -0700248import java.util.Collections;
Zak Cohen658c67a2018-10-19 14:21:05 -0700249import java.util.HashMap;
Sunny Goyal4390ace2014-10-13 11:33:11 -0700250import java.util.HashSet;
Michael Jurkad7c28052012-04-27 15:43:36 -0700251import java.util.List;
Anushree Ganjam97434ee2023-05-18 22:03:16 +0000252import java.util.Map;
Thiru Ramasamy694407c2022-03-08 12:11:24 -0800253import java.util.Optional;
Sunny Goyalaae6fbb2019-01-31 16:05:58 -0800254import java.util.function.Predicate;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700255import java.util.function.Supplier;
Sunny Goyal3a1eadd2019-10-23 17:44:27 -0700256import java.util.stream.Stream;
Jon Mirandaf5197fc2019-09-04 16:55:41 -0700257
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800258/**
259 * Default launcher application.
260 */
Shikha Malhotra0f2e1b62022-03-27 21:02:21 +0000261public class Launcher extends StatefulActivity<LauncherState>
262 implements LauncherExterns, Callbacks, InvariantDeviceProfile.OnIDPChangeListener,
Sunny Goyal82379182022-11-02 18:58:49 -0700263 PluginListener<LauncherOverlayPlugin> {
Vadim Tryshevfedca432015-08-19 17:55:02 -0700264 public static final String TAG = "Launcher";
Sunny Goyale84c5b82019-09-26 17:05:31 -0700265
266 public static final ActivityTracker<Launcher> ACTIVITY_TRACKER = new ActivityTracker<>();
267
Sunny Goyal2bba4c32015-05-18 15:42:48 -0700268 static final boolean LOGD = false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800269
Winson Chunga2413752012-04-03 14:22:34 -0700270 static final boolean DEBUG_STRICT_MODE = false;
Romain Guy6fefcf12009-06-11 13:07:43 -0700271
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800272 private static final int REQUEST_CREATE_SHORTCUT = 1;
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700273 private static final int REQUEST_CREATE_APPWIDGET = 5;
Jon Mirandac476d6e2017-05-04 16:30:01 -0700274
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700275 private static final int REQUEST_PICK_APPWIDGET = 9;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800276
Michael Jurka8b805b12012-04-18 14:23:14 -0700277 private static final int REQUEST_BIND_APPWIDGET = 11;
Sunny Goyal8a2a63b2018-03-06 22:15:18 -0800278 public static final int REQUEST_BIND_PENDING_APPWIDGET = 12;
279 public static final int REQUEST_RECONFIGURE_APPWIDGET = 13;
Michael Jurka8b805b12012-04-18 14:23:14 -0700280
Sunny Goyal5a1f53b2015-05-27 10:24:24 -0700281 private static final float BOUNCE_ANIMATION_TENSION = 1.3f;
282
Mathew Inwood876a8462013-06-14 14:12:41 +0100283 /**
284 * IntentStarter uses request codes starting with this. This must be greater than all activity
285 * request codes used internally.
286 */
287 protected static final int REQUEST_LAST = 100;
288
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800289 // Type: int
Jeremy Simc94f4b72022-06-10 11:43:37 -0700290 protected static final String RUNTIME_STATE = "launcher.state";
Sunny Goyal2100c782016-08-22 16:00:03 -0700291 // Type: PendingRequestArgs
292 private static final String RUNTIME_STATE_PENDING_REQUEST_ARGS = "launcher.request_args";
Sunny Goyaldedda052019-05-14 15:23:48 -0700293 // Type: int
294 private static final String RUNTIME_STATE_PENDING_REQUEST_CODE = "launcher.request_code";
Sunny Goyal2100c782016-08-22 16:00:03 -0700295 // Type: ActivityResultInfo
296 private static final String RUNTIME_STATE_PENDING_ACTIVITY_RESULT = "launcher.activity_result";
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -0700297 // Type: SparseArray<Parcelable>
298 private static final String RUNTIME_STATE_WIDGET_PANEL = "launcher.widget_panel";
Sunny Goyal12e3f1f2021-07-15 14:31:58 -0700299 // Type int[]
300 private static final String RUNTIME_STATE_CURRENT_SCREEN_IDS = "launcher.current_screen_ids";
Sunny Goyal17c72fb2019-10-14 14:06:38 -0700301
Jeremy Simc94f4b72022-06-10 11:43:37 -0700302 // Type PendingSplitSelectInfo<Parcelable>
303 protected static final String PENDING_SPLIT_SELECT_INFO = "launcher.pending_split_select_info";
304
Tracy Zhoucb93ec52023-03-31 22:51:17 -0700305 public static final String INTENT_ACTION_ALL_APPS_TOGGLE =
306 "launcher.intent_action_all_apps_toggle";
307
vadimt00d42552018-12-11 17:59:36 -0800308 public static final String ON_CREATE_EVT = "Launcher.onCreate";
Sunny Goyal17c72fb2019-10-14 14:06:38 -0700309 public static final String ON_START_EVT = "Launcher.onStart";
310 public static final String ON_RESUME_EVT = "Launcher.onResume";
311 public static final String ON_NEW_INTENT_EVT = "Launcher.onNewIntent";
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800312
Fengjiang Li5a36c172023-04-13 18:18:27 +0000313 private static boolean sIsNewProcess = true;
314
Sunny Goyal35e7d382020-05-08 13:37:58 -0700315 private StateManager<LauncherState> mStateManager;
Patrick Dubroy6b509c12010-08-23 15:08:16 -0700316
Adam Cohenad4e15c2013-10-17 16:21:35 -0700317 private static final int ON_ACTIVITY_RESULT_ANIMATION_DELAY = 500;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800318
Winson Chunga2413752012-04-03 14:22:34 -0700319 // How long to wait before the new-shortcut animation automatically pans the workspace
Jon Mirandaf5197fc2019-09-04 16:55:41 -0700320 @VisibleForTesting public static final int NEW_APPS_PAGE_MOVE_DELAY = 500;
Rajeev Kumar43c0f582017-06-23 15:34:55 -0700321 private static final int NEW_APPS_ANIMATION_INACTIVE_TIMEOUT_SECONDS = 5;
Jon Mirandaf5197fc2019-09-04 16:55:41 -0700322 @Thunk @VisibleForTesting public static final int NEW_APPS_ANIMATION_DELAY = 500;
Winson Chunga2413752012-04-03 14:22:34 -0700323
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -0700324 private static final String DISPLAY_WORKSPACE_TRACE_METHOD_NAME = "DisplayWorkspaceFirstFrame";
325 private static final String DISPLAY_ALL_APPS_TRACE_METHOD_NAME = "DisplayAllApps";
326 public static final int DISPLAY_WORKSPACE_TRACE_COOKIE = 0;
327 public static final int DISPLAY_ALL_APPS_TRACE_COOKIE = 1;
328
Alex Chau0c4e11b2022-07-08 18:41:36 +0100329 private static final FloatProperty<Workspace<?>> WORKSPACE_WIDGET_SCALE =
330 WORKSPACE_SCALE_PROPERTY_FACTORY.get(SCALE_INDEX_WIDGET_TRANSITION);
331 private static final FloatProperty<Hotseat> HOTSEAT_WIDGET_SCALE =
332 HOTSEAT_SCALE_PROPERTY_FACTORY.get(SCALE_INDEX_WIDGET_TRANSITION);
333
Sukesh Ram3f2338a2023-08-28 18:31:54 +0000334 private static final boolean DESKTOP_MODE_SUPPORTED =
Ats Jenk8121e0d2022-12-01 11:34:43 -0800335 "1".equals(Utilities.getSystemProperty("persist.wm.debug.desktop_mode_2", "0"));
336
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700337 @Thunk
Shikha Malhotra0f2e1b62022-03-27 21:02:21 +0000338 Workspace<?> mWorkspace;
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700339 @Thunk
340 DragLayer mDragLayer;
Sunny Goyal322d5562015-06-25 19:35:49 -0700341
Sunny Goyal337c81f2019-12-10 12:19:13 -0800342 private WidgetManagerHelper mAppWidgetManager;
Sihua Ma0593a0d2022-10-03 16:01:48 -0700343 private LauncherWidgetHolder mAppWidgetHolder;
Romain Guycbb89e42009-06-08 15:52:54 -0700344
Rajeev Kumar43c0f582017-06-23 15:34:55 -0700345 private final int[] mTmpAddItemCellCoordinates = new int[2];
Michael Jurka0280c3b2010-09-17 15:00:07 -0700346
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700347 @Thunk
348 Hotseat mHotseat;
Adam Cohenf358a4b2013-07-23 16:47:31 -0700349
Sunny Goyal47328fd2016-05-25 18:56:41 -0700350 private DropTargetBar mDropTargetBar;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700351
352 // Main container view for the all apps screen.
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700353 @Thunk
Brian Isganitis1664c9f2022-01-14 23:15:47 -0500354 ActivityAllAppsContainerView<Launcher> mAppsView;
Hyunyoung Song645764e2016-06-06 14:19:02 -0700355 AllAppsTransitionController mAllAppsController;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700356
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400357 // Scrim view for the all apps and overview state.
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700358 @Thunk
359 ScrimView mScrimView;
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400360
Winson Chung8ae41982017-11-10 11:42:13 -0800361 // UI and state for the overview panel
Sunny Goyal7c7be8c2018-03-07 19:58:07 -0800362 private View mOverviewPanel;
Winson Chung8ae41982017-11-10 11:42:13 -0800363
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700364 @Thunk
365 boolean mWorkspaceLoading = true;
Joe Onorato9c1289c2009-08-17 11:03:03 -0400366
Winson Chungc9bf6d42019-10-04 15:33:18 -0700367 // Used to notify when an activity launch has been deferred because launcher is not yet resumed
368 // TODO: See if we can remove this later
369 private Runnable mOnDeferredActivityLaunchCallback;
370
Sunny Goyal527c7d32015-08-28 15:19:36 -0700371 private ViewOnDrawExecutor mPendingExecutor;
Sunny Goyal7b8d63f2022-04-14 16:37:32 -0700372 private OnPreDrawListener mOnInitialBindListener;
Michael Jurka7607c2f2013-04-03 14:33:19 -0700373
Joe Onorato9c1289c2009-08-17 11:03:03 -0400374 private LauncherModel mModel;
Sunny Goyal43bf11d2017-02-02 13:52:53 -0800375 private ModelWriter mModelWriter;
Joe Onorato0589f0f2010-02-08 13:44:00 -0800376 private IconCache mIconCache;
Sunny Goyalae502842016-06-17 08:43:56 -0700377 private LauncherAccessibilityDelegate mAccessibilityDelegate;
Joe Onorato9c1289c2009-08-17 11:03:03 -0400378
Tony Wickham010d2552017-01-20 08:15:28 -0800379 private PopupDataProvider mPopupDataProvider;
Tony Wickhambfbf7f92016-05-19 11:19:39 -0700380
Andras Kloczl55edfe52021-05-14 12:21:30 +0200381 private IntSet mSynchronouslyBoundPages = new IntSet();
Sunny Goyal12e3f1f2021-07-15 14:31:58 -0700382 @NonNull private IntSet mPagesToBindSynchronously = new IntSet();
Adam Cohen1462de32012-07-24 22:34:36 -0700383
Winson Chung46353de2012-02-16 14:05:10 -0800384 // We only want to get the SharedPreferences once since it does an FS stat each time we get
385 // it from the context.
386 private SharedPreferences mSharedPrefs;
Brian Isganitis099945b2022-01-31 18:15:00 -0500387 private OnboardingPrefs<? extends Launcher> mOnboardingPrefs;
Winson Chung46353de2012-02-16 14:05:10 -0800388
Sunny Goyal2100c782016-08-22 16:00:03 -0700389 // Activity result which needs to be processed after workspace has loaded.
390 private ActivityResultInfo mPendingActivityResult;
391 /**
392 * Holds extra information required to handle a result from an external call, like
393 * {@link #startActivityForResult(Intent, int)} or {@link #requestPermissions(String[], int)}
394 */
395 private PendingRequestArgs mPendingRequestArgs;
Sunny Goyaldedda052019-05-14 15:23:48 -0700396 // Request id for any pending activity result
Sunny Goyal210e1742019-10-17 12:05:38 -0700397 protected int mPendingActivityRequestCode = -1;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800398
Tracy Zhou4d7b2442019-12-09 13:42:57 -0800399 private ViewGroupFocusHelper mFocusHandler;
Hyunyoung Song7fb3ccc2017-10-17 15:39:46 -0700400
Sunny Goyal623eddd2018-03-02 12:24:41 -0800401 private RotationHelper mRotationHelper;
Sunny Goyal7779d622015-06-11 16:18:39 -0700402
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700403 protected LauncherOverlayManager mOverlayManager;
Abhilasha Chahalcb329352022-05-31 15:50:53 +0000404 protected DragController mDragController;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700405 // If true, overlay callbacks are deferred
406 private boolean mDeferOverlayCallbacks;
407 private final Runnable mDeferredOverlayCallbacks = this::checkIfOverlayStillDeferred;
408
Riddle Hsu979da642020-09-22 21:52:40 +0800409 protected long mLastTouchUpTime = -1;
Sunny Goyala306e592020-03-24 01:51:41 -0700410 private boolean mTouchInProgress;
Sunny Goyal9b180102020-03-11 10:02:29 -0700411
thiruramc96873c2021-02-11 15:13:47 -0800412 // New InstanceId is assigned to mAllAppsSessionLogId for each AllApps sessions.
413 // When Launcher is not in AllApps state mAllAppsSessionLogId will be null.
414 // User actions within AllApps state are logged with this InstanceId, to recreate AllApps
415 // session on the server side.
416 protected InstanceId mAllAppsSessionLogId;
417 private LauncherState mPrevLauncherState;
418
kholoud mohamedc76b2032021-12-20 16:47:38 +0000419 private StringCache mStringCache;
Becky Qiu4ed3dfc2022-10-19 16:58:22 -0700420 private BaseSearchConfig mBaseSearchConfig;
Fengjiang Li5a36c172023-04-13 18:18:27 +0000421 private StartupLatencyLogger mStartupLatencyLogger;
Sunny Goyal669b71f2023-01-27 14:37:07 -0800422 private CellPosMapper mCellPosMapper = CellPosMapper.DEFAULT;
423
Sunny Goyal0ee66472023-08-17 16:19:22 -0700424 private final CannedAnimationCoordinator mAnimationCoordinator =
425 new CannedAnimationCoordinator(this);
426
Vinit Nayak65460402023-08-11 15:40:07 -0700427 private final List<BackPressHandler> mBackPressedHandlers = new ArrayList<>();
428
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800429 @Override
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -0700430 @TargetApi(Build.VERSION_CODES.S)
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800431 protected void onCreate(Bundle savedInstanceState) {
Fengjiang Li5a36c172023-04-13 18:18:27 +0000432 mStartupLatencyLogger = createStartupLatencyLogger(
433 sIsNewProcess
434 ? LockedUserState.get(this).isUserUnlockedAtLauncherStartup()
435 ? COLD
436 : COLD_DEVICE_REBOOTING
437 : WARM);
438 sIsNewProcess = false;
439 mStartupLatencyLogger
440 .logStart(LAUNCHER_LATENCY_STARTUP_TOTAL_DURATION)
441 .logStart(LAUNCHER_LATENCY_STARTUP_ACTIVITY_ON_CREATE);
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -0700442 // Only use a hard-coded cookie since we only want to trace this once.
443 if (Utilities.ATLEAST_S) {
444 Trace.beginAsyncSection(
445 DISPLAY_WORKSPACE_TRACE_METHOD_NAME, DISPLAY_WORKSPACE_TRACE_COOKIE);
446 Trace.beginAsyncSection(DISPLAY_ALL_APPS_TRACE_METHOD_NAME,
447 DISPLAY_ALL_APPS_TRACE_COOKIE);
448 }
Sunny Goyal67736672023-06-02 13:35:19 +0000449 TraceHelper.INSTANCE.beginSection(ON_CREATE_EVT);
Winson Chunga2413752012-04-03 14:22:34 -0700450 if (DEBUG_STRICT_MODE) {
451 StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
452 .detectDiskReads()
453 .detectDiskWrites()
454 .detectNetwork() // or .detectAll() for all detectable problems
455 .penaltyLog()
456 .build());
457 StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
458 .detectLeakedSqlLiteObjects()
459 .detectLeakedClosableObjects()
460 .penaltyLog()
461 .penaltyDeath()
462 .build());
463 }
464
Tony Wickhame78a70b2021-03-29 16:45:59 -0700465 if (Utilities.IS_DEBUG_DEVICE && FeatureFlags.NOTIFY_CRASHES.get()) {
466 final String notificationChannelId = "com.android.launcher3.Debug";
467 final String notificationChannelName = "Debug";
468 final String notificationTag = "Debug";
469 final int notificationId = 0;
470
471 NotificationManager notificationManager = getSystemService(NotificationManager.class);
472 notificationManager.createNotificationChannel(new NotificationChannel(
473 notificationChannelId, notificationChannelName,
474 NotificationManager.IMPORTANCE_HIGH));
475
476 Thread.currentThread().setUncaughtExceptionHandler((thread, throwable) -> {
477 String stackTrace = Log.getStackTraceString(throwable);
478
479 Intent shareIntent = new Intent(Intent.ACTION_SEND);
480 shareIntent.setType("text/plain");
481 shareIntent.putExtra(Intent.EXTRA_TEXT, stackTrace);
482 shareIntent = Intent.createChooser(shareIntent, null);
483 PendingIntent sharePendingIntent = PendingIntent.getActivity(
Sunny Goyalcd2ac0f2022-04-14 21:21:47 -0700484 this, 0, shareIntent, FLAG_UPDATE_CURRENT | FLAG_IMMUTABLE);
Tony Wickhame78a70b2021-03-29 16:45:59 -0700485
486 Notification notification = new Notification.Builder(this, notificationChannelId)
487 .setSmallIcon(android.R.drawable.ic_menu_close_clear_cancel)
488 .setContentTitle("Launcher crash detected!")
489 .setStyle(new Notification.BigTextStyle().bigText(stackTrace))
490 .addAction(android.R.drawable.ic_menu_share, "Share", sharePendingIntent)
491 .build();
492 notificationManager.notify(notificationTag, notificationId, notification);
493
494 Thread.UncaughtExceptionHandler defaultUncaughtExceptionHandler =
495 Thread.getDefaultUncaughtExceptionHandler();
496 if (defaultUncaughtExceptionHandler != null) {
497 defaultUncaughtExceptionHandler.uncaughtException(thread, throwable);
498 }
499 });
500 }
501
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800502 super.onCreate(savedInstanceState);
Daniel Sandlere060b0b2013-06-27 21:47:55 -0400503
Sunny Goyal87f784c2017-01-11 10:48:34 -0800504 LauncherAppState app = LauncherAppState.getInstance(this);
Sunny Goyala7a5bf32020-01-05 15:35:29 +0530505 mModel = app.getModel();
Sunny Goyal9d89f752020-06-19 11:09:24 -0700506
Sunny Goyal41d51a02019-05-14 09:44:34 -0700507 mRotationHelper = new RotationHelper(this);
Hyunyoung Song31971a32019-01-27 12:31:12 -0800508 InvariantDeviceProfile idp = app.getInvariantDeviceProfile();
509 initDeviceProfile(idp);
510 idp.addOnChangeListener(this);
Stefan Andonian146701c2022-11-10 23:07:40 +0000511 mSharedPrefs = LauncherPrefs.getPrefs(this);
Joe Onorato0589f0f2010-02-08 13:44:00 -0800512 mIconCache = app.getIconCache();
Sunny Goyal384b5782021-02-09 22:50:02 -0800513 mAccessibilityDelegate = createAccessibilityDelegate();
Adam Cohen2e6da152015-05-06 11:42:25 -0700514
Abhilasha Chahalcb329352022-05-31 15:50:53 +0000515 initDragController();
Hyunyoung Song645764e2016-06-06 14:19:02 -0700516 mAllAppsController = new AllAppsTransitionController(this);
Sunny Goyal35e7d382020-05-08 13:37:58 -0700517 mStateManager = new StateManager<>(this, NORMAL);
Romain Guycbb89e42009-06-08 15:52:54 -0700518
Sunny Goyal35e7d382020-05-08 13:37:58 -0700519 mOnboardingPrefs = createOnboardingPrefs(mSharedPrefs);
Tony Wickham133cd542020-04-08 17:48:41 -0700520
Luca Zuccarini81f5cee2022-10-11 13:02:09 +0000521 // TODO: move the SearchConfig to SearchState when new LauncherState is created.
522 mBaseSearchConfig = new BaseSearchConfig();
523
Schneider Victor-tuliasfb2affa2023-05-26 15:09:41 -0700524 setupViews();
525
Sunny Goyal337c81f2019-12-10 12:19:13 -0800526 mAppWidgetManager = new WidgetManagerHelper(this);
Sihua Ma0593a0d2022-10-03 16:01:48 -0700527 mAppWidgetHolder = createAppWidgetHolder();
528 mAppWidgetHolder.startListening();
Romain Guycbb89e42009-06-08 15:52:54 -0700529
Sunny Goyal9c2b9602020-01-07 13:07:55 -0800530 mPopupDataProvider = new PopupDataProvider(this::updateNotificationDots);
Tony Wickham010d2552017-01-20 08:15:28 -0800531
Sunny Goyale84c5b82019-09-26 17:05:31 -0700532 boolean internalStateHandled = ACTIVITY_TRACKER.handleCreate(this);
Sunny Goyald3864fa2017-11-14 15:06:36 -0800533 if (internalStateHandled) {
Sunny Goyald3864fa2017-11-14 15:06:36 -0800534 if (savedInstanceState != null) {
535 // InternalStateHandler has already set the appropriate state.
536 // We dont need to do anything.
537 savedInstanceState.remove(RUNTIME_STATE);
538 }
539 }
540 restoreState(savedInstanceState);
Sunny Goyalbbece862019-03-01 13:13:52 -0800541 mStateManager.reapplyState();
Winson Chungb63b44c2017-11-10 17:54:44 -0800542
Sunny Goyalfe770c92016-09-27 14:38:58 -0700543 if (savedInstanceState != null) {
Sunny Goyal12e3f1f2021-07-15 14:31:58 -0700544 int[] pageIds = savedInstanceState.getIntArray(RUNTIME_STATE_CURRENT_SCREEN_IDS);
545 if (pageIds != null) {
546 mPagesToBindSynchronously = IntSet.wrap(pageIds);
547 }
Sunny Goyalfe770c92016-09-27 14:38:58 -0700548 }
Sunny Goyald3864fa2017-11-14 15:06:36 -0800549
Fengjiang Li5a36c172023-04-13 18:18:27 +0000550 mStartupLatencyLogger.logWorkspaceLoadStartTime();
Sunny Goyala7a5bf32020-01-05 15:35:29 +0530551 if (!mModel.addCallbacksAndLoad(this)) {
Sunny Goyald3864fa2017-11-14 15:06:36 -0800552 if (!internalStateHandled) {
Sunny Goyal7b8d63f2022-04-14 16:37:32 -0700553 // If we are not binding synchronously, pause drawing until initial bind complete,
554 // so that the system could continue to show the device loading prompt
555 mOnInitialBindListener = Boolean.FALSE::booleanValue;
Sunny Goyald3864fa2017-11-14 15:06:36 -0800556 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800557 }
558
559 // For handling default keys
Sunny Goyalf4aceab2017-12-06 16:16:31 -0800560 setDefaultKeyMode(DEFAULT_KEYS_SEARCH_LOCAL);
Joe Onorato34a0e1b2009-12-14 17:44:51 -0800561
Sunny Goyal9d89f752020-06-19 11:09:24 -0700562 setContentView(getRootView());
Xiaowen Lei3c0f30a2023-04-12 16:59:45 -0700563 ComposeInitializer.initCompose(this);
564
Sunny Goyal7b8d63f2022-04-14 16:37:32 -0700565 if (mOnInitialBindListener != null) {
566 getRootView().getViewTreeObserver().addOnPreDrawListener(mOnInitialBindListener);
567 }
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800568 getRootView().dispatchInsets();
Mario Bertschlera6936942017-05-31 14:48:19 -0700569
Sunny Goyala992ac92023-01-10 17:50:32 -0800570 // Listen for screen turning off
571 ScreenOnTracker.INSTANCE.get(this).addListener(mScreenOnListener);
Sunny Goyal8392c822017-06-20 10:03:56 -0700572 getSystemUiController().updateUiState(SystemUiController.UI_STATE_BASE_WINDOW,
573 Themes.getAttrBoolean(this, R.attr.isWorkspaceDarkText));
Sunny Goyal14b32402017-07-31 10:03:28 -0700574
575 if (mLauncherCallbacks != null) {
576 mLauncherCallbacks.onCreate(savedInstanceState);
577 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700578 mOverlayManager = getDefaultOverlay();
579 PluginManagerWrapper.INSTANCE.get(this).addPluginListener(this,
Sunny Goyal80a071b2021-12-27 13:30:08 +0530580 LauncherOverlayPlugin.class, false /* allowedMultiple */);
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700581
Sunny Goyal623eddd2018-03-02 12:24:41 -0800582 mRotationHelper.initialize();
Sunny Goyal67736672023-06-02 13:35:19 +0000583 TraceHelper.INSTANCE.endSection();
Samuel Fufa41d909f2020-03-20 16:27:09 -0700584
Schneider Victor-tulias8a35c762020-09-03 14:30:10 -0700585 if (Utilities.ATLEAST_R) {
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -0700586 getWindow().setSoftInputMode(LayoutParams.SOFT_INPUT_ADJUST_NOTHING);
Schneider Victor-tulias8a35c762020-09-03 14:30:10 -0700587 }
Stefan Andonian45fc3012022-05-05 22:48:09 +0000588 setTitle(R.string.home_screen);
Fengjiang Li5a36c172023-04-13 18:18:27 +0000589 mStartupLatencyLogger.logEnd(LAUNCHER_LATENCY_STARTUP_ACTIVITY_ON_CREATE);
590 }
591
592 /**
593 * Create {@link StartupLatencyLogger} that only collects launcher startup latency metrics
594 * without sending them anywhere. Child class can override this method to create logger
595 * that overrides {@link StartupLatencyLogger#log()} to report those metrics.
596 */
597 protected StartupLatencyLogger createStartupLatencyLogger(
598 StatsLogManager.StatsLatencyLogger.LatencyType latencyType) {
599 return new StartupLatencyLogger(latencyType);
Adam Cohen9211d422014-10-07 18:14:53 -0700600 }
601
Fengjiang Li6bb8d792023-01-12 16:20:58 -0800602 /**
Fengjiang Lib7860bd2023-03-15 10:50:50 -0700603 * Provide {@link OnBackAnimationCallback} in below order:
Fengjiang Li6bb8d792023-01-12 16:20:58 -0800604 * <ol>
605 * <li> auto cancel action mode handler
606 * <li> drag handler
607 * <li> view handler
Vinit Nayak65460402023-08-11 15:40:07 -0700608 * <li> registered {@link BackPressHandler}
Fengjiang Li6bb8d792023-01-12 16:20:58 -0800609 * <li> state handler
610 * </ol>
611 *
612 * A back gesture (a single click on back button, or a swipe back gesture that contains a series
613 * of swipe events) should be handled by the same handler from above list. For a new back
614 * gesture, a new handler should be regenerated.
615 *
616 * Note that state handler will always be handling the back press event if the previous 3 don't.
617 */
618 @NonNull
Fengjiang Lid0c23592023-04-20 16:42:25 -0700619 @RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
Fengjiang Lib7860bd2023-03-15 10:50:50 -0700620 protected OnBackAnimationCallback getOnBackAnimationCallback() {
Fengjiang Li6bb8d792023-01-12 16:20:58 -0800621 // #1 auto cancel action mode handler
622 if (isInAutoCancelActionMode()) {
623 return this::finishAutoCancelActionMode;
624 }
625
626 // #2 drag handler
627 if (mDragController.isDragging()) {
628 return mDragController::cancelDrag;
629 }
630
631 // #3 view handler
632 AbstractFloatingView topView =
633 AbstractFloatingView.getTopOpenView(Launcher.this);
634 if (topView != null && topView.canHandleBack()) {
635 return topView;
636 }
637
Vinit Nayak65460402023-08-11 15:40:07 -0700638 // #4 Custom back handlers
639 for (BackPressHandler handler : mBackPressedHandlers) {
640 if (handler.canHandleBack()) {
641 return handler;
642 }
643 }
644
645 // #5 state handler
Fengjiang Lib7860bd2023-03-15 10:50:50 -0700646 return new OnBackAnimationCallback() {
Fengjiang Li6bb8d792023-01-12 16:20:58 -0800647 @Override
648 public void onBackInvoked() {
649 onStateBack();
650 }
651
652 @Override
Fengjiang Lib7860bd2023-03-15 10:50:50 -0700653 public void onBackProgressed(@NonNull BackEvent backEvent) {
Fengjiang Li6bb8d792023-01-12 16:20:58 -0800654 mStateManager.getState().onBackProgressed(
Fengjiang Lib7860bd2023-03-15 10:50:50 -0700655 Launcher.this, backEvent.getProgress());
Fengjiang Li6bb8d792023-01-12 16:20:58 -0800656 }
657
658 @Override
659 public void onBackCancelled() {
660 mStateManager.getState().onBackCancelled(Launcher.this);
661 }
662 };
663 }
664
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700665 protected LauncherOverlayManager getDefaultOverlay() {
666 return new LauncherOverlayManager() { };
667 }
668
Brian Isganitis099945b2022-01-31 18:15:00 -0500669 protected OnboardingPrefs<? extends Launcher> createOnboardingPrefs(
670 SharedPreferences sharedPrefs) {
Sunny Goyal35e7d382020-05-08 13:37:58 -0700671 return new OnboardingPrefs<>(this, sharedPrefs);
Tony Wickham133cd542020-04-08 17:48:41 -0700672 }
673
Brian Isganitis099945b2022-01-31 18:15:00 -0500674 public OnboardingPrefs<? extends Launcher> getOnboardingPrefs() {
Tony Wickham133cd542020-04-08 17:48:41 -0700675 return mOnboardingPrefs;
676 }
677
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700678 @Override
Sunny Goyal80a071b2021-12-27 13:30:08 +0530679 public void onPluginConnected(LauncherOverlayPlugin overlayManager, Context context) {
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700680 switchOverlay(() -> overlayManager.createOverlayManager(this, this));
681 }
682
683 @Override
Sunny Goyal80a071b2021-12-27 13:30:08 +0530684 public void onPluginDisconnected(LauncherOverlayPlugin plugin) {
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700685 switchOverlay(this::getDefaultOverlay);
686 }
687
688 private void switchOverlay(Supplier<LauncherOverlayManager> overlaySupplier) {
689 if (mOverlayManager != null) {
690 mOverlayManager.onActivityDestroyed(this);
691 }
692 mOverlayManager = overlaySupplier.get();
693 if (getRootView().isAttachedToWindow()) {
694 mOverlayManager.onAttachedToWindow();
695 }
696 mDeferOverlayCallbacks = true;
697 checkIfOverlayStillDeferred();
698 }
699
700 @Override
Brian Isganitis099945b2022-01-31 18:15:00 -0500701 public void dispatchDeviceProfileChanged() {
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700702 super.dispatchDeviceProfileChanged();
703 mOverlayManager.onDeviceProvideChanged();
704 }
705
Sunny Goyal7779d622015-06-11 16:18:39 -0700706 @Override
Winson Chung8eb49e02018-07-16 13:33:31 -0700707 public void onEnterAnimationComplete() {
708 super.onEnterAnimationComplete();
Sunny Goyalbe8c3402019-05-22 15:17:52 -0700709 mRotationHelper.setCurrentTransitionRequest(REQUEST_NONE);
Sunny Goyal5c20fdd2022-04-05 20:58:03 -0700710 // Starting with Android S, onEnterAnimationComplete is sent immediately
711 // causing the surface to get removed before the animation completed (b/175345344).
712 // Instead we rely on next user touch event to remove the view and optionally a callback
713 // from system from Android T onwards.
714 if (!Utilities.ATLEAST_S) {
715 AbstractFloatingView.closeOpenViews(this, false, TYPE_ICON_SURFACE);
716 }
Winson Chung8eb49e02018-07-16 13:33:31 -0700717 }
718
719 @Override
Jerry Chang09b40242021-08-27 13:29:01 +0800720 public void onMultiWindowModeChanged(boolean isInMultiWindowMode, Configuration newConfig) {
721 super.onMultiWindowModeChanged(isInMultiWindowMode, newConfig);
722 // Always update device profile when multi window mode changed.
723 initDeviceProfile(mDeviceProfile.inv);
724 dispatchDeviceProfileChanged();
725 }
726
Abhilasha Chahalcb329352022-05-31 15:50:53 +0000727 /**
728 * Initializes the drag controller.
729 */
730 protected void initDragController() {
731 mDragController = new LauncherDragController(this);
732 }
733
Sunny Goyal605bcf32018-03-02 15:16:12 -0800734 @Override
Sunny Goyal6e6f7992021-08-24 16:23:29 -0700735 public void onIdpChanged(boolean modelPropertiesChanged) {
Alex Chau360ec032022-08-10 16:11:42 +0100736 onHandleConfigurationChanged();
737 }
738
739 @Override
740 protected void onHandleConfigurationChanged() {
Nicolo' Mazzucatoe120fcf2023-08-04 15:33:15 +0000741 Trace.beginSection("Launcher#onHandleconfigurationChanged");
742 try {
743 if (!initDeviceProfile(mDeviceProfile.inv)) {
744 return;
745 }
746
747 dispatchDeviceProfileChanged();
748 reapplyUi();
749 mDragLayer.recreateControllers();
750
751 // Calling onSaveInstanceState ensures that static cache used by listWidgets is
752 // initialized properly.
753 onSaveInstanceState(new Bundle());
754 mModel.rebindCallbacks();
755 } finally {
756 Trace.endSection();
Alex Chau6209af62022-07-27 14:08:23 +0100757 }
Hyunyoung Song31971a32019-01-27 12:31:12 -0800758 }
759
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400760 public void onAssistantVisibilityChanged(float visibility) {
Sunny Goyal0b5b8d42021-03-31 14:56:47 -0700761 mHotseat.getQsb().setAlpha(1f - visibility);
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400762 }
763
Bill Lina1221bc2021-06-03 01:49:27 +0800764 /**
Alex Chau6209af62022-07-27 14:08:23 +0100765 * Returns {@code true} if a new DeviceProfile is initialized, and {@code false} otherwise.
766 */
767 protected boolean initDeviceProfile(InvariantDeviceProfile idp) {
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800768 // Load configuration-specific DeviceProfile
Alex Chau6209af62022-07-27 14:08:23 +0100769 DeviceProfile deviceProfile = idp.getDeviceProfile(this);
770 if (mDeviceProfile == deviceProfile) {
771 return false;
772 }
773
774 mDeviceProfile = deviceProfile;
Jerry Changbfac46a2021-09-08 08:20:58 +0800775 if (isInMultiWindowMode()) {
776 mDeviceProfile = mDeviceProfile.getMultiWindowProfile(
777 this, getMultiWindowDisplaySize());
778 }
Sunny Goyalae6e3182019-04-30 12:04:37 -0700779
Sunny Goyal59d086c2018-05-07 17:31:40 -0700780 onDeviceProfileInitiated();
Sebastián Franco1f4d56c2023-08-08 03:29:10 +0000781 if (FOLDABLE_SINGLE_PAGE.get() && mDeviceProfile.isTwoPanels) {
Sebastian Franco09589322022-11-02 15:25:58 -0700782 mCellPosMapper = new TwoPanelCellPosMapper(mDeviceProfile.inv.numColumns);
783 } else {
784 mCellPosMapper = CellPosMapper.DEFAULT;
785 }
Sunny Goyal669b71f2023-01-27 14:37:07 -0800786 mModelWriter = mModel.getWriter(getDeviceProfile().isVerticalBarLayout(), true,
787 mCellPosMapper, this);
Alex Chau6209af62022-07-27 14:08:23 +0100788 return true;
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800789 }
790
Sunny Goyal669b71f2023-01-27 14:37:07 -0800791 @Override
792 public CellPosMapper getCellPosMapper() {
793 return mCellPosMapper;
794 }
795
Sunny Goyal623eddd2018-03-02 12:24:41 -0800796 public RotationHelper getRotationHelper() {
797 return mRotationHelper;
798 }
799
Tracy Zhou4d7b2442019-12-09 13:42:57 -0800800 public ViewGroupFocusHelper getFocusHandler() {
801 return mFocusHandler;
802 }
803
Sunny Goyal35e7d382020-05-08 13:37:58 -0700804 @Override
805 public StateManager<LauncherState> getStateManager() {
Sunny Goyal3e3f44c2017-10-23 17:14:52 -0700806 return mStateManager;
Sunny Goyalbe93f262017-10-20 17:05:27 -0700807 }
808
Adam Cohen9211d422014-10-07 18:14:53 -0700809 private LauncherCallbacks mLauncherCallbacks;
810
Sunny Goyal32554d12015-12-03 15:31:25 -0800811 /**
812 * Call this after onCreate to set or clear overlay.
813 */
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700814 @Override
Sunny Goyal32554d12015-12-03 15:31:25 -0800815 public void setLauncherOverlay(LauncherOverlay overlay) {
Sunny Goyal32554d12015-12-03 15:31:25 -0800816 mWorkspace.setLauncherOverlay(overlay);
817 }
818
Adam Cohen9211d422014-10-07 18:14:53 -0700819 public boolean setLauncherCallbacks(LauncherCallbacks callbacks) {
820 mLauncherCallbacks = callbacks;
821 return true;
Adam Cohenf9426d52012-06-04 17:26:21 -0700822 }
823
Hyunyoung Song3f471442015-04-08 19:01:34 -0700824 public boolean isDraggingEnabled() {
Winson Chung36a62fe2012-05-06 18:04:42 -0700825 // We prevent dragging when we are loading the workspace as it is possible to pick up a view
826 // that is subsequently removed from the workspace in startBinding().
Sunny Goyal639e9062015-08-19 19:17:06 -0700827 return !isWorkspaceLoading();
Winson Chung36a62fe2012-05-06 18:04:42 -0700828 }
829
Schneider Victor-tulias5173fd82021-10-19 14:47:23 -0700830 @NonNull
831 @Override
Tony Wickham010d2552017-01-20 08:15:28 -0800832 public PopupDataProvider getPopupDataProvider() {
833 return mPopupDataProvider;
834 }
835
Sunny Goyal0b0847b2018-03-14 12:30:11 -0700836 @Override
Tony Wickhamf34bee82018-12-03 18:11:39 -0800837 public DotInfo getDotInfoForItem(ItemInfo info) {
838 return mPopupDataProvider.getDotInfoForItem(info);
Sunny Goyal0b0847b2018-03-14 12:30:11 -0700839 }
840
841 @Override
842 public void invalidateParent(ItemInfo info) {
Jon Mirandae6f3fa42019-03-04 09:14:40 -0800843 if (info.container >= 0) {
Sunny Goyal0b0847b2018-03-14 12:30:11 -0700844 View folderIcon = getWorkspace().getHomescreenIconByItemId(info.container);
Jon Mirandae6f3fa42019-03-04 09:14:40 -0800845 if (folderIcon instanceof FolderIcon && folderIcon.getTag() instanceof FolderInfo) {
Sunny Goyal11a50742019-08-07 09:24:26 -0700846 if (new FolderGridOrganizer(getDeviceProfile().inv)
847 .setFolderInfo((FolderInfo) folderIcon.getTag())
848 .isItemInPreview(info.rank)) {
Jon Mirandae6f3fa42019-03-04 09:14:40 -0800849 folderIcon.invalidate();
850 }
Sunny Goyal0b0847b2018-03-14 12:30:11 -0700851 }
852 }
853 }
854
Adam Cohenc76e1dd2013-11-14 11:09:14 +0000855 /**
Winson Chung557d6ed2011-07-08 15:34:52 -0700856 * Returns whether we should delay spring loaded mode -- for shortcuts and widgets that have
857 * a configuration step, this allows the proper animations to run after other transitions.
858 */
Sunny Goyalefb7e842018-10-04 15:11:00 -0700859 private int completeAdd(
Sunny Goyal2100c782016-08-22 16:00:03 -0700860 int requestCode, Intent intent, int appWidgetId, PendingRequestArgs info) {
Sunny Goyal669b71f2023-01-27 14:37:07 -0800861 CellPos cellPos = getCellPosMapper().mapModelToPresenter(info);
862 int screenId = cellPos.screenId;
863 if (info.container == CONTAINER_DESKTOP) {
Adam Cohen83079e42014-09-19 17:43:08 -0700864 // When the screen id represents an actual screen (as opposed to a rank) we make sure
865 // that the drop page actually exists.
Sunny Goyal669b71f2023-01-27 14:37:07 -0800866 screenId = ensurePendingDropLayoutExists(cellPos.screenId);
Adam Cohen83079e42014-09-19 17:43:08 -0700867 }
Adam Cohendb364c32014-05-20 14:23:40 -0700868
Sunny Goyal2100c782016-08-22 16:00:03 -0700869 switch (requestCode) {
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800870 case REQUEST_CREATE_SHORTCUT:
Sunny Goyal669b71f2023-01-27 14:37:07 -0800871 completeAddShortcut(intent, info.container, screenId,
872 cellPos.cellX, cellPos.cellY, info);
Pinyao Tingc9074272019-11-11 11:51:44 -0800873 announceForAccessibility(R.string.item_added_to_workspace);
Winson Chungb8472bb2011-08-05 13:49:21 -0700874 break;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800875 case REQUEST_CREATE_APPWIDGET:
Sunny Goyal2100c782016-08-22 16:00:03 -0700876 completeAddAppWidget(appWidgetId, info, null, null);
Winson Chungb8472bb2011-08-05 13:49:21 -0700877 break;
Sunny Goyalff572272014-07-23 13:58:07 -0700878 case REQUEST_RECONFIGURE_APPWIDGET:
Sunny Goyal977838b2022-06-27 13:15:41 -0700879 getStatsLogManager().logger().withItemInfo(info).log(LAUNCHER_WIDGET_RECONFIGURED);
Sunny Goyal2100c782016-08-22 16:00:03 -0700880 completeRestoreAppWidget(appWidgetId, LauncherAppWidgetInfo.RESTORE_COMPLETED);
Sunny Goyalff572272014-07-23 13:58:07 -0700881 break;
Sunny Goyald478c832016-04-01 12:04:16 -0700882 case REQUEST_BIND_PENDING_APPWIDGET: {
Sunny Goyal2100c782016-08-22 16:00:03 -0700883 int widgetId = appWidgetId;
884 LauncherAppWidgetInfo widgetInfo =
Sunny Goyald478c832016-04-01 12:04:16 -0700885 completeRestoreAppWidget(widgetId, LauncherAppWidgetInfo.FLAG_UI_NOT_READY);
Sunny Goyal2100c782016-08-22 16:00:03 -0700886 if (widgetInfo != null) {
Sunny Goyald478c832016-04-01 12:04:16 -0700887 // Since the view was just bound, also launch the configure activity if needed
888 LauncherAppWidgetProviderInfo provider = mAppWidgetManager
fbaron30d9e3f2023-08-03 17:03:59 -0700889 .getLauncherAppWidgetInfo(widgetId, info.getTargetComponent());
Sunny Goyal04a324a2017-01-20 21:08:59 -0800890 if (provider != null) {
891 new WidgetAddFlowHandler(provider)
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700892 .startConfigActivity(this, widgetInfo,
893 REQUEST_RECONFIGURE_APPWIDGET);
Sunny Goyald478c832016-04-01 12:04:16 -0700894 }
895 }
896 break;
897 }
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800898 }
Adam Cohendb364c32014-05-20 14:23:40 -0700899 return screenId;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800900 }
901
Adam Cohenc7cd2cb2014-11-17 17:45:34 -0800902 private void handleActivityResult(
Michael Jurka8b805b12012-04-18 14:23:14 -0700903 final int requestCode, final int resultCode, final Intent data) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700904 if (isWorkspaceLoading()) {
905 // process the result once the workspace has loaded.
906 mPendingActivityResult = new ActivityResultInfo(requestCode, resultCode, data);
907 return;
908 }
909 mPendingActivityResult = null;
910
Winson Chunge341d302013-08-16 14:31:00 -0700911 // Reset the startActivity waiting flag
Sunny Goyal2100c782016-08-22 16:00:03 -0700912 final PendingRequestArgs requestArgs = mPendingRequestArgs;
913 setWaitingForResult(null);
914 if (requestArgs == null) {
915 return;
916 }
917
918 final int pendingAddWidgetId = requestArgs.getWidgetId();
Winson Chunge341d302013-08-16 14:31:00 -0700919
Charlie Anderson438d4052023-04-25 14:38:57 -0400920 Runnable exitSpringLoaded = MULTI_SELECT_EDIT_MODE.get() ? null
921 : () -> mStateManager.goToState(NORMAL, SPRING_LOADED_EXIT_DELAY);
Adam Cohenad4e15c2013-10-17 16:21:35 -0700922
Michael Jurka8b805b12012-04-18 14:23:14 -0700923 if (requestCode == REQUEST_BIND_APPWIDGET) {
Winsona1f79d32015-08-05 14:00:45 -0700924 // This is called only if the user did not previously have permissions to bind widgets
Adam Cohenad4e15c2013-10-17 16:21:35 -0700925 final int appWidgetId = data != null ?
Michael Jurka8b805b12012-04-18 14:23:14 -0700926 data.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1) : -1;
927 if (resultCode == RESULT_CANCELED) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700928 completeTwoStageWidgetDrop(RESULT_CANCELED, appWidgetId, requestArgs);
Sunny Goyal6e379fc2020-03-19 16:08:14 -0700929 mWorkspace.removeExtraEmptyScreenDelayed(
930 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false, exitSpringLoaded);
Michael Jurka8b805b12012-04-18 14:23:14 -0700931 } else if (resultCode == RESULT_OK) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700932 addAppWidgetImpl(
933 appWidgetId, requestArgs, null,
Sunny Goyal04a324a2017-01-20 21:08:59 -0800934 requestArgs.getWidgetHandler(),
Sunny Goyal2100c782016-08-22 16:00:03 -0700935 ON_ACTIVITY_RESULT_ANIMATION_DELAY);
Michael Jurka8b805b12012-04-18 14:23:14 -0700936 }
937 return;
938 }
Michael Jurka336fd4f2013-09-12 00:05:02 +0200939
Adam Cohened66b2b2012-01-23 17:28:51 -0800940 boolean isWidgetDrop = (requestCode == REQUEST_PICK_APPWIDGET ||
Sunny Goyal5c97f512015-05-19 16:03:28 -0700941 requestCode == REQUEST_CREATE_APPWIDGET);
Romain Guyaad5ef42009-06-10 02:48:37 -0700942
Adam Cohened66b2b2012-01-23 17:28:51 -0800943 // We have special handling for widgets
944 if (isWidgetDrop) {
Adam Cohen4637b5a2013-11-04 18:21:24 -0800945 final int appWidgetId;
946 int widgetId = data != null ? data.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1)
947 : -1;
948 if (widgetId < 0) {
949 appWidgetId = pendingAddWidgetId;
950 } else {
951 appWidgetId = widgetId;
952 }
953
Adam Cohenad4e15c2013-10-17 16:21:35 -0700954 final int result;
Adam Cohenf0129b12013-11-04 17:57:36 -0800955 if (appWidgetId < 0 || resultCode == RESULT_CANCELED) {
Adam Cohendb364c32014-05-20 14:23:40 -0700956 Log.e(TAG, "Error: appWidgetId (EXTRA_APPWIDGET_ID) was not " +
957 "returned from the widget configuration activity.");
Adam Cohenad4e15c2013-10-17 16:21:35 -0700958 result = RESULT_CANCELED;
Sunny Goyal2100c782016-08-22 16:00:03 -0700959 completeTwoStageWidgetDrop(result, appWidgetId, requestArgs);
Sunny Goyal6e379fc2020-03-19 16:08:14 -0700960 mWorkspace.removeExtraEmptyScreenDelayed(
961 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false,
962 () -> getStateManager().goToState(NORMAL));
Sunny Goyal2100c782016-08-22 16:00:03 -0700963 } else {
Sunny Goyal669b71f2023-01-27 14:37:07 -0800964 CellPos presenterPos = getCellPosMapper().mapModelToPresenter(requestArgs);
965 if (requestArgs.container == CONTAINER_DESKTOP) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700966 // When the screen id represents an actual screen (as opposed to a rank)
967 // we make sure that the drop page actually exists.
Sunny Goyal669b71f2023-01-27 14:37:07 -0800968 int newScreenId = ensurePendingDropLayoutExists(presenterPos.screenId);
969 requestArgs.screenId = getCellPosMapper().mapPresenterToModel(
970 presenterPos.cellX, presenterPos.cellY, newScreenId, CONTAINER_DESKTOP)
971 .screenId;
Adam Cohendb364c32014-05-20 14:23:40 -0700972 }
Sunny Goyal2100c782016-08-22 16:00:03 -0700973 final CellLayout dropLayout =
Sunny Goyal669b71f2023-01-27 14:37:07 -0800974 mWorkspace.getScreenWithId(presenterPos.screenId);
Sunny Goyal2100c782016-08-22 16:00:03 -0700975
976 dropLayout.setDropPending(true);
977 final Runnable onComplete = new Runnable() {
978 @Override
979 public void run() {
980 completeTwoStageWidgetDrop(resultCode, appWidgetId, requestArgs);
981 dropLayout.setDropPending(false);
982 }
983 };
Sunny Goyal6e379fc2020-03-19 16:08:14 -0700984 mWorkspace.removeExtraEmptyScreenDelayed(
985 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false, onComplete);
Winson Chung5aaab772012-04-27 15:24:02 -0700986 }
Adam Cohened66b2b2012-01-23 17:28:51 -0800987 return;
988 }
989
Sunny Goyald478c832016-04-01 12:04:16 -0700990 if (requestCode == REQUEST_RECONFIGURE_APPWIDGET
991 || requestCode == REQUEST_BIND_PENDING_APPWIDGET) {
Sunny Goyalff572272014-07-23 13:58:07 -0700992 if (resultCode == RESULT_OK) {
993 // Update the widget view.
Sunny Goyal2100c782016-08-22 16:00:03 -0700994 completeAdd(requestCode, data, pendingAddWidgetId, requestArgs);
Sunny Goyalff572272014-07-23 13:58:07 -0700995 }
996 // Leave the widget in the pending state if the user canceled the configure.
997 return;
998 }
999
Sunny Goyalaad90582015-07-09 14:22:50 -07001000 if (requestCode == REQUEST_CREATE_SHORTCUT) {
1001 // Handle custom shortcuts created using ACTION_CREATE_SHORTCUT.
Sunny Goyal2100c782016-08-22 16:00:03 -07001002 if (resultCode == RESULT_OK && requestArgs.container != ItemInfo.NO_ID) {
1003 completeAdd(requestCode, data, -1, requestArgs);
Sunny Goyal6e379fc2020-03-19 16:08:14 -07001004 mWorkspace.removeExtraEmptyScreenDelayed(
1005 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false, exitSpringLoaded);
Sunny Goyal2100c782016-08-22 16:00:03 -07001006
Sunny Goyalaad90582015-07-09 14:22:50 -07001007 } else if (resultCode == RESULT_CANCELED) {
Sunny Goyal6e379fc2020-03-19 16:08:14 -07001008 mWorkspace.removeExtraEmptyScreenDelayed(
1009 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false, exitSpringLoaded);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001010 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001011 }
Hongming Jind91cb6e2020-01-27 16:23:03 -08001012
Adam Cohened66b2b2012-01-23 17:28:51 -08001013 mDragLayer.clearAnimatedView();
Adam Cohenc7cd2cb2014-11-17 17:45:34 -08001014 }
1015
1016 @Override
Sunny Goyal64a75aa2017-07-03 13:50:52 -07001017 public void onActivityResult(
Adam Cohenc7cd2cb2014-11-17 17:45:34 -08001018 final int requestCode, final int resultCode, final Intent data) {
Sunny Goyaldedda052019-05-14 15:23:48 -07001019 mPendingActivityRequestCode = -1;
Adam Cohenc7cd2cb2014-11-17 17:45:34 -08001020 handleActivityResult(requestCode, resultCode, data);
Adam Cohened66b2b2012-01-23 17:28:51 -08001021 }
1022
Adam Cohendb364c32014-05-20 14:23:40 -07001023 /**
1024 * Check to see if a given screen id exists. If not, create it at the end, return the new id.
1025 *
1026 * @param screenId the screen id to check
1027 * @return the new screen, or screenId if it exists
1028 */
Sunny Goyalefb7e842018-10-04 15:11:00 -07001029 private int ensurePendingDropLayoutExists(int screenId) {
Sunny Goyal32554d12015-12-03 15:31:25 -08001030 CellLayout dropLayout = mWorkspace.getScreenWithId(screenId);
Adam Cohendb364c32014-05-20 14:23:40 -07001031 if (dropLayout == null) {
1032 // it's possible that the add screen was removed because it was
1033 // empty and a re-bind occurred
Andras Kloczl408a54f2021-08-28 00:59:08 +01001034 mWorkspace.addExtraEmptyScreens();
1035 IntSet emptyPagesAdded = mWorkspace.commitExtraEmptyScreens();
1036 return emptyPagesAdded.isEmpty() ? -1 : emptyPagesAdded.getArray().get(0);
Adam Cohendb364c32014-05-20 14:23:40 -07001037 }
Andras Kloczl408a54f2021-08-28 00:59:08 +01001038 return screenId;
Adam Cohendb364c32014-05-20 14:23:40 -07001039 }
1040
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001041 @Thunk
1042 void completeTwoStageWidgetDrop(
Sunny Goyal2100c782016-08-22 16:00:03 -07001043 final int resultCode, final int appWidgetId, final PendingRequestArgs requestArgs) {
Sunny Goyal669b71f2023-01-27 14:37:07 -08001044 CellLayout cellLayout = mWorkspace.getScreenWithId(
1045 getCellPosMapper().mapModelToPresenter(requestArgs).screenId);
Adam Cohened66b2b2012-01-23 17:28:51 -08001046 Runnable onCompleteRunnable = null;
1047 int animationType = 0;
1048
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001049 AppWidgetHostView boundWidget = null;
Adam Cohened66b2b2012-01-23 17:28:51 -08001050 if (resultCode == RESULT_OK) {
1051 animationType = Workspace.COMPLETE_TWO_STAGE_WIDGET_DROP_ANIMATION;
Sihua Ma0593a0d2022-10-03 16:01:48 -07001052 final AppWidgetHostView layout = mAppWidgetHolder.createView(this, appWidgetId,
Sunny Goyal04a324a2017-01-20 21:08:59 -08001053 requestArgs.getWidgetHandler().getProviderInfo(this));
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001054 boundWidget = layout;
Charlie Anderson438d4052023-04-25 14:38:57 -04001055 onCompleteRunnable = () -> {
1056 completeAddAppWidget(appWidgetId, requestArgs, layout, null);
1057 if (!isInState(EDIT_MODE)) {
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001058 mStateManager.goToState(NORMAL, SPRING_LOADED_EXIT_DELAY);
Adam Cohened66b2b2012-01-23 17:28:51 -08001059 }
1060 };
1061 } else if (resultCode == RESULT_CANCELED) {
Sihua Ma0593a0d2022-10-03 16:01:48 -07001062 mAppWidgetHolder.deleteAppWidgetId(appWidgetId);
Adam Cohened66b2b2012-01-23 17:28:51 -08001063 animationType = Workspace.CANCEL_TWO_STAGE_WIDGET_DROP_ANIMATION;
Adam Cohened66b2b2012-01-23 17:28:51 -08001064 }
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001065 if (mDragLayer.getAnimatedView() != null) {
Sunny Goyal2100c782016-08-22 16:00:03 -07001066 mWorkspace.animateWidgetDrop(requestArgs, cellLayout,
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001067 (DragView) mDragLayer.getAnimatedView(), onCompleteRunnable,
1068 animationType, boundWidget, true);
Adam Cohenad4e15c2013-10-17 16:21:35 -07001069 } else if (onCompleteRunnable != null) {
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001070 // The animated view may be null in the case of a rotation during widget configuration
1071 onCompleteRunnable.run();
1072 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001073 }
1074
1075 @Override
Michael Jurkacd496d72013-04-11 11:32:45 -07001076 protected void onStop() {
1077 super.onStop();
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001078 if (mDeferOverlayCallbacks) {
1079 checkIfOverlayStillDeferred();
1080 } else {
1081 mOverlayManager.onActivityStopped(this);
Adam Cohen9211d422014-10-07 18:14:53 -07001082 }
Hyunyoung Song5ee7c132021-05-11 13:52:36 -07001083 hideKeyboard();
Hyunyoung Song95786e02020-09-15 00:34:10 -07001084 logStopAndResume(false /* isResume */);
Sihua Ma0593a0d2022-10-03 16:01:48 -07001085 mAppWidgetHolder.setActivityStarted(false);
Schneider Victor-tulias5173fd82021-10-19 14:47:23 -07001086 NotificationListener.removeNotificationsChangedListener(getPopupDataProvider());
Winson Chung7c500162023-06-14 18:58:27 +00001087 FloatingIconView.resetIconLoadResult();
Michael Jurkacd496d72013-04-11 11:32:45 -07001088 }
1089
1090 @Override
1091 protected void onStart() {
Sunny Goyal67736672023-06-02 13:35:19 +00001092 TraceHelper.INSTANCE.beginSection(ON_START_EVT);
Michael Jurkacd496d72013-04-11 11:32:45 -07001093 super.onStart();
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001094 if (!mDeferOverlayCallbacks) {
1095 mOverlayManager.onActivityStarted(this);
Adam Cohen9211d422014-10-07 18:14:53 -07001096 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001097
Sihua Ma0593a0d2022-10-03 16:01:48 -07001098 mAppWidgetHolder.setActivityStarted(true);
Sunny Goyal67736672023-06-02 13:35:19 +00001099 TraceHelper.INSTANCE.endSection();
Michael Jurkacd496d72013-04-11 11:32:45 -07001100 }
1101
Sunny Goyal35e7d382020-05-08 13:37:58 -07001102 @Override
1103 @CallSuper
1104 protected void onDeferredResumed() {
Hyunyoung Song95786e02020-09-15 00:34:10 -07001105 logStopAndResume(true /* isResume */);
Sunny Goyala002c6c2019-02-12 16:20:10 -08001106
Sunny Goyal35e7d382020-05-08 13:37:58 -07001107 // Process any items that were added while Launcher was away.
Sunny Goyal60e68c92020-08-12 13:59:27 -07001108 ItemInstallQueue.INSTANCE.get(this)
1109 .resumeModelPush(FLAG_ACTIVITY_PAUSED);
Sunny Goyale9c6f4c2019-05-30 11:35:25 -07001110
Sunny Goyal35e7d382020-05-08 13:37:58 -07001111 // Refresh shortcuts if the permission changed.
Sunny Goyal8b74cc72020-07-27 17:50:33 -07001112 mModel.validateModelDataOnResume();
Sunny Goyale9c6f4c2019-05-30 11:35:25 -07001113
Sunny Goyal35e7d382020-05-08 13:37:58 -07001114 // Set the notification listener and fetch updated notifications when we resume
Schneider Victor-tulias5173fd82021-10-19 14:47:23 -07001115 NotificationListener.addNotificationsChangedListener(mPopupDataProvider);
Winson Chung87583112019-06-10 14:20:58 -07001116
Sunny Goyal35e7d382020-05-08 13:37:58 -07001117 DiscoveryBounce.showForHomeIfNeeded(this);
Sihua Ma0593a0d2022-10-03 16:01:48 -07001118 mAppWidgetHolder.setActivityResumed(true);
Sunny Goyaldedda052019-05-14 15:23:48 -07001119 }
1120
Hyunyoung Song95786e02020-09-15 00:34:10 -07001121 private void logStopAndResume(boolean isResume) {
Hyunyoung Song77e29772020-08-25 00:53:48 -07001122 if (mPendingExecutor != null) return;
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001123 int pageIndex = mWorkspace.isOverlayShown() ? -1 : mWorkspace.getCurrentPage();
Hyunyoung Song95786e02020-09-15 00:34:10 -07001124 int statsLogOrdinal = mStateManager.getState().statsLogOrdinal;
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001125
1126 StatsLogManager.EventEnum event;
1127 StatsLogManager.StatsLogger logger = getStatsLogManager().logger();
Hyunyoung Song95786e02020-09-15 00:34:10 -07001128 if (isResume) {
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001129 logger.withSrcState(LAUNCHER_STATE_BACKGROUND)
Hyunyoung Song95786e02020-09-15 00:34:10 -07001130 .withDstState(mStateManager.getState().statsLogOrdinal);
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001131 event = LAUNCHER_ONRESUME;
1132 } else { /* command == Action.Command.STOP */
Hyunyoung Song95786e02020-09-15 00:34:10 -07001133 logger.withSrcState(mStateManager.getState().statsLogOrdinal)
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001134 .withDstState(LAUNCHER_STATE_BACKGROUND);
1135 event = LAUNCHER_ONSTOP;
1136 }
1137
Hyunyoung Song95786e02020-09-15 00:34:10 -07001138 if (statsLogOrdinal == LAUNCHER_STATE_HOME && mWorkspace != null) {
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001139 logger.withContainerInfo(LauncherAtom.ContainerInfo.newBuilder()
1140 .setWorkspace(
1141 LauncherAtom.WorkspaceContainer.newBuilder()
1142 .setPageIndex(pageIndex)).build());
Becky Qiubfc2da12019-08-01 11:09:38 -07001143 }
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001144 logger.log(event);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001145 }
Becky Qiubfc2da12019-08-01 11:09:38 -07001146
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001147 private void scheduleDeferredCheck() {
1148 mHandler.removeCallbacks(mDeferredOverlayCallbacks);
1149 postAsyncCallback(mHandler, mDeferredOverlayCallbacks);
1150 }
1151
1152 private void checkIfOverlayStillDeferred() {
1153 if (!mDeferOverlayCallbacks) {
1154 return;
1155 }
Sunny Goyal8f965462020-04-23 19:00:36 -07001156 if (isStarted() && (!hasBeenResumed()
1157 || mStateManager.getState().hasFlag(FLAG_NON_INTERACTIVE))) {
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001158 return;
1159 }
1160 mDeferOverlayCallbacks = false;
1161
1162 // Move the client to the correct state. Calling the same method twice is no-op.
1163 if (isStarted()) {
1164 mOverlayManager.onActivityStarted(this);
1165 }
1166 if (hasBeenResumed()) {
1167 mOverlayManager.onActivityResumed(this);
1168 } else {
1169 mOverlayManager.onActivityPaused(this);
1170 }
1171 if (!isStarted()) {
1172 mOverlayManager.onActivityStopped(this);
1173 }
1174 }
1175
1176 public void deferOverlayCallbacksUntilNextResumeOrStop() {
1177 mDeferOverlayCallbacks = true;
1178 }
1179
1180 public LauncherOverlayManager getOverlayManager() {
1181 return mOverlayManager;
Becky Qiubfc2da12019-08-01 11:09:38 -07001182 }
1183
Sunny Goyal35e7d382020-05-08 13:37:58 -07001184 @Override
Winson Chungef528762019-09-06 12:05:52 -07001185 public void onStateSetStart(LauncherState state) {
Sunny Goyal35e7d382020-05-08 13:37:58 -07001186 super.onStateSetStart(state);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001187 if (mDeferOverlayCallbacks) {
1188 scheduleDeferredCheck();
Sunny Goyale9c6f4c2019-05-30 11:35:25 -07001189 }
Sunny Goyal210e1742019-10-17 12:05:38 -07001190 addActivityFlags(ACTIVITY_STATE_TRANSITION_ACTIVE);
Sunny Goyal8f965462020-04-23 19:00:36 -07001191
Charlie Anderson438d4052023-04-25 14:38:57 -04001192 if (state == SPRING_LOADED || state == EDIT_MODE) {
Sunny Goyal8f965462020-04-23 19:00:36 -07001193 // Prevent any Un/InstallShortcutReceivers from updating the db while we are
1194 // not on homescreen
Sunny Goyal60e68c92020-08-12 13:59:27 -07001195 ItemInstallQueue.INSTANCE.get(this).pauseModelPush(FLAG_DRAG_AND_DROP);
Sunny Goyal8f965462020-04-23 19:00:36 -07001196 getRotationHelper().setCurrentStateRequest(REQUEST_LOCK);
1197
1198 mWorkspace.showPageIndicatorAtCurrentScroll();
1199 mWorkspace.setClipChildren(false);
1200 }
1201 // When multiple pages are visible, show persistent page indicator
1202 mWorkspace.getPageIndicator().setShouldAutoHide(!state.hasFlag(FLAG_MULTI_PAGE));
thiruram0eabc782021-04-02 14:30:10 -07001203
thiruramc96873c2021-02-11 15:13:47 -08001204 mPrevLauncherState = mStateManager.getCurrentStableState();
thiruram0eabc782021-04-02 14:30:10 -07001205 if (mPrevLauncherState != state && ALL_APPS.equals(state)
1206 // Making sure mAllAppsSessionLogId is null to avoid double logging.
1207 && mAllAppsSessionLogId == null) {
1208 // creates new instance ID since new all apps session is started.
1209 mAllAppsSessionLogId = new InstanceIdSequence().newInstanceId();
Thiru Ramasamy694407c2022-03-08 12:11:24 -08001210 if (getAllAppsEntryEvent().isPresent()) {
1211 getStatsLogManager().logger()
1212 .withContainerInfo(ContainerInfo.newBuilder()
1213 .setWorkspace(WorkspaceContainer.newBuilder()
1214 .setPageIndex(getWorkspace().getCurrentPage())).build())
1215 .log(getAllAppsEntryEvent().get());
1216 }
thiruram0eabc782021-04-02 14:30:10 -07001217 }
Sunny Goyal1eb11242022-09-09 17:14:45 -07001218 updateDisallowBack();
Sunny Goyaldedda052019-05-14 15:23:48 -07001219 }
1220
Thiru Ramasamy5fbac632022-01-28 15:05:36 -08001221 /**
1222 * Returns {@link EventEnum} that should be logged when Launcher enters into AllApps state.
1223 */
Thiru Ramasamy694407c2022-03-08 12:11:24 -08001224 protected Optional<EventEnum> getAllAppsEntryEvent() {
1225 return Optional.of(FeatureFlags.ENABLE_DEVICE_SEARCH.get()
Thiru Ramasamy5fbac632022-01-28 15:05:36 -08001226 ? LAUNCHER_ALLAPPS_ENTRY_WITH_DEVICE_SEARCH
Thiru Ramasamy694407c2022-03-08 12:11:24 -08001227 : LAUNCHER_ALLAPPS_ENTRY);
Thiru Ramasamy5fbac632022-01-28 15:05:36 -08001228 }
1229
Sunny Goyal35e7d382020-05-08 13:37:58 -07001230 @Override
Winson Chungef528762019-09-06 12:05:52 -07001231 public void onStateSetEnd(LauncherState state) {
Sunny Goyalfee1b252020-12-14 12:30:38 -08001232 super.onStateSetEnd(state);
Sihua Ma0593a0d2022-10-03 16:01:48 -07001233 getAppWidgetHolder().setStateIsNormal(state == LauncherState.NORMAL);
Sunny Goyal8f965462020-04-23 19:00:36 -07001234 getWorkspace().setClipChildren(!state.hasFlag(FLAG_MULTI_PAGE));
1235
Winson Chungef528762019-09-06 12:05:52 -07001236 finishAutoCancelActionMode();
Sunny Goyal210e1742019-10-17 12:05:38 -07001237 removeActivityFlags(ACTIVITY_STATE_TRANSITION_ACTIVE);
Sunny Goyal8f965462020-04-23 19:00:36 -07001238
1239 // dispatch window state changed
1240 getWindow().getDecorView().sendAccessibilityEvent(TYPE_WINDOW_STATE_CHANGED);
1241 AccessibilityManagerCompat.sendStateEventToTest(this, state.ordinal);
1242
1243 if (state == NORMAL) {
1244 // Re-enable any Un/InstallShortcutReceiver and now process any queued items
Sunny Goyal60e68c92020-08-12 13:59:27 -07001245 ItemInstallQueue.INSTANCE.get(this)
1246 .resumeModelPush(FLAG_DRAG_AND_DROP);
Sunny Goyal8f965462020-04-23 19:00:36 -07001247
1248 // Clear any rotation locks when going to normal state
1249 getRotationHelper().setCurrentStateRequest(REQUEST_NONE);
1250 }
thiruramc96873c2021-02-11 15:13:47 -08001251
thiruramea56f842021-06-02 16:02:37 -07001252 if (ALL_APPS.equals(mPrevLauncherState) && !ALL_APPS.equals(state)
thiruram0eabc782021-04-02 14:30:10 -07001253 // Making sure mAllAppsSessionLogId is not null to avoid double logging.
thiruramc96873c2021-02-11 15:13:47 -08001254 && mAllAppsSessionLogId != null) {
Samuel Fuface820f52021-06-18 17:23:48 -05001255 getAppsView().reset(false);
Thiru Ramasamy694407c2022-03-08 12:11:24 -08001256 getAllAppsExitEvent().ifPresent(getStatsLogManager().logger()::log);
thiruramc96873c2021-02-11 15:13:47 -08001257 mAllAppsSessionLogId = null;
1258 }
Winson Chungef528762019-09-06 12:05:52 -07001259 }
1260
Thiru Ramasamy694407c2022-03-08 12:11:24 -08001261 /**
1262 * Returns {@link EventEnum} that should be logged when Launcher exists from AllApps state.
1263 */
1264 protected Optional<EventEnum> getAllAppsExitEvent() {
1265 return Optional.of(LAUNCHER_ALLAPPS_EXIT);
1266 }
1267
Michael Jurkacd496d72013-04-11 11:32:45 -07001268 @Override
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001269 protected void onResume() {
Sunny Goyal67736672023-06-02 13:35:19 +00001270 TraceHelper.INSTANCE.beginSection(ON_RESUME_EVT);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001271 super.onResume();
Sunny Goyalfca6bc92017-09-28 16:28:34 -07001272
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001273 if (mDeferOverlayCallbacks) {
1274 scheduleDeferredCheck();
1275 } else {
1276 mOverlayManager.onActivityResumed(this);
Adam Cohen9211d422014-10-07 18:14:53 -07001277 }
Mario Bertschler0fc6f682017-02-17 12:16:13 -08001278
Jon Mirandaa82a7dc2022-05-10 11:48:32 -07001279 DragView.removeAllViews(this);
Sunny Goyal67736672023-06-02 13:35:19 +00001280 TraceHelper.INSTANCE.endSection();
Adam Cohen06dff352012-06-01 17:17:08 -07001281 }
1282
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001283 @Override
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001284 protected void onPause() {
Winson Chung997a9232013-07-24 15:33:46 -07001285 // Ensure that items added to Launcher are queued until Launcher returns
Sunny Goyal60e68c92020-08-12 13:59:27 -07001286 ItemInstallQueue.INSTANCE.get(this).pauseModelPush(FLAG_ACTIVITY_PAUSED);
Winson Chung997a9232013-07-24 15:33:46 -07001287
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001288 super.onPause();
Joe Onorato24b6fd82009-11-12 13:47:09 -08001289 mDragController.cancelDrag();
Sunny Goyal9b180102020-03-11 10:02:29 -07001290 mLastTouchUpTime = -1;
Hyunyoung Song497708c2019-05-01 16:16:53 -07001291 mDropTargetBar.animateToVisibility(false);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001292
1293 if (!mDeferOverlayCallbacks) {
1294 mOverlayManager.onActivityPaused(this);
Adam Cohenbffe7452013-07-22 18:21:45 -07001295 }
Sihua Ma0593a0d2022-10-03 16:01:48 -07001296 mAppWidgetHolder.setActivityResumed(false);
Adam Cohenbffe7452013-07-22 18:21:45 -07001297 }
1298
Lucas Dupin87d75202021-07-28 10:24:54 -07001299 /**
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001300 * Restores the previous state, if it exists.
1301 *
1302 * @param savedState The previous state.
1303 */
1304 private void restoreState(Bundle savedState) {
1305 if (savedState == null) {
1306 return;
1307 }
1308
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001309 int stateOrdinal = savedState.getInt(RUNTIME_STATE, NORMAL.ordinal);
Sunny Goyalf9403d92017-10-18 10:55:56 -07001310 LauncherState[] stateValues = LauncherState.values();
1311 LauncherState state = stateValues[stateOrdinal];
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08001312
1313 NonConfigInstance lastInstance = (NonConfigInstance) getLastNonConfigurationInstance();
1314 boolean forceRestore = lastInstance != null
1315 && (lastInstance.config.diff(mOldConfig) & CONFIG_UI_MODE) != 0;
1316 if (forceRestore || !state.shouldDisableRestore()) {
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001317 mStateManager.goToState(state, false /* animated */);
Joe Onorato3a8820b2009-11-10 15:06:42 -08001318 }
1319
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001320 PendingRequestArgs requestArgs = savedState.getParcelable(
1321 RUNTIME_STATE_PENDING_REQUEST_ARGS);
Sunny Goyal2100c782016-08-22 16:00:03 -07001322 if (requestArgs != null) {
1323 setWaitingForResult(requestArgs);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001324 }
Sunny Goyaldedda052019-05-14 15:23:48 -07001325 mPendingActivityRequestCode = savedState.getInt(RUNTIME_STATE_PENDING_REQUEST_CODE);
Sunny Goyal2100c782016-08-22 16:00:03 -07001326
1327 mPendingActivityResult = savedState.getParcelable(RUNTIME_STATE_PENDING_ACTIVITY_RESULT);
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001328
1329 SparseArray<Parcelable> widgetsState =
1330 savedState.getSparseParcelableArray(RUNTIME_STATE_WIDGET_PANEL);
1331 if (widgetsState != null) {
1332 WidgetsFullSheet.show(this, false).restoreHierarchyState(widgetsState);
1333 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001334 }
1335
1336 /**
1337 * Finds all the views we need and configure them properly.
1338 */
Tony Wickham04fca162020-02-05 15:06:52 -08001339 protected void setupViews() {
Fengjiang Li5a36c172023-04-13 18:18:27 +00001340 mStartupLatencyLogger.logStart(LAUNCHER_LATENCY_STARTUP_VIEW_INFLATION);
Becky Qiu3aec5d52022-09-16 11:17:50 -07001341 inflateRootView(R.layout.launcher);
Fengjiang Li5a36c172023-04-13 18:18:27 +00001342 mStartupLatencyLogger.logEnd(LAUNCHER_LATENCY_STARTUP_VIEW_INFLATION);
1343
Sunny Goyalcc96aa12018-01-11 09:56:07 -08001344 mDragLayer = findViewById(R.id.drag_layer);
Sunny Goyal3333b0c2016-05-09 20:43:21 -07001345 mFocusHandler = mDragLayer.getFocusIndicatorHelper();
Sunny Goyal966d9012017-06-06 16:43:59 -07001346 mWorkspace = mDragLayer.findViewById(R.id.workspace);
Sunny Goyald0a6ae72016-06-16 12:29:03 -07001347 mWorkspace.initParentViews(mDragLayer);
Sreyas321bfae2020-02-21 17:53:02 -08001348 mOverviewPanel = findViewById(R.id.overview_panel);
Sunny Goyal7c7be8c2018-03-07 19:58:07 -08001349 mHotseat = findViewById(R.id.hotseat);
Adam Cohenb66675a2020-05-15 16:16:17 -07001350 mHotseat.setWorkspace(mWorkspace);
Craig Mautner360310b2012-10-26 15:13:08 -07001351
Winson Chung4c98d922011-05-31 16:50:48 -07001352 // Setup the drag layer
Sunny Goyal5d1873a2018-05-08 11:10:44 -07001353 mDragLayer.setup(mDragController, mWorkspace);
Winson Chung4c98d922011-05-31 16:50:48 -07001354
Hyunyoung Song645764e2016-06-06 14:19:02 -07001355 mWorkspace.setup(mDragController);
Winsonc7d2e832016-07-28 12:24:55 -07001356 // Until the workspace is bound, ensure that we keep the wallpaper offset locked to the
1357 // default state, otherwise we will update to the wrong offsets in RTL
1358 mWorkspace.lockWallpaperToDefaultPage();
Sunny Goyalbb030562021-07-19 16:28:39 -07001359 mWorkspace.bindAndInitFirstWorkspaceScreen();
Hyunyoung Song645764e2016-06-06 14:19:02 -07001360 mDragController.addDragListener(mWorkspace);
Winson Chung4c98d922011-05-31 16:50:48 -07001361
Tony Wickham34d2c912015-09-11 09:27:58 -07001362 // Get the search/delete/uninstall bar
Rajeev Kumar43c0f582017-06-23 15:34:55 -07001363 mDropTargetBar = mDragLayer.findViewById(R.id.drop_target_bar);
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07001364
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001365 // Setup Apps
1366 mAppsView = findViewById(R.id.apps_view);
Fengjiang Lid080b982023-02-01 15:30:30 -08001367 mAppsView.setAllAppsTransitionController(mAllAppsController);
Craig Mautner360310b2012-10-26 15:13:08 -07001368
Govinda Wassermanc06e1512019-04-09 09:56:53 -04001369 // Setup Scrim
1370 mScrimView = findViewById(R.id.scrim_view);
1371
Winson Chung3d503fb2011-07-13 17:25:49 -07001372 // Setup the drag controller (drop targets have to be added in reverse order in priority)
Sunny Goyal47328fd2016-05-25 18:56:41 -07001373 mDropTargetBar.setup(mDragController);
Samuel Fufaacebd1f2021-05-06 10:02:03 -05001374 mAllAppsController.setupViews(mScrimView, mAppsView);
Federico Baron3f255eb2022-12-22 14:40:58 -08001375
1376 if (SHOW_DOT_PAGINATION.get()) {
1377 mWorkspace.getPageIndicator().setShouldAutoHide(true);
Sunny Goyal5cd1b192023-04-06 22:33:11 +00001378 mWorkspace.getPageIndicator().setPaintColor(
1379 Themes.getAttrBoolean(this, R.attr.isWorkspaceDarkText)
1380 ? Color.BLACK
1381 : Color.WHITE);
Federico Baron3f255eb2022-12-22 14:40:58 -08001382 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001383 }
1384
Federico Baron7539d762022-09-29 09:47:04 -07001385 @Override
1386 public View onCreateView(View parent, String name, Context context, AttributeSet attrs) {
Federico Baron3f255eb2022-12-22 14:40:58 -08001387 if (SHOW_DOT_PAGINATION.get() && WorkspacePageIndicator.class.getName().equals(name)) {
Federico Baron7539d762022-09-29 09:47:04 -07001388 return LayoutInflater.from(context).inflate(R.layout.page_indicator_dots,
1389 (ViewGroup) parent, false);
1390 }
1391 return super.onCreateView(parent, name, context, attrs);
1392 }
1393
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001394 /**
1395 * Creates a view representing a shortcut.
1396 *
1397 * @param info The data structure describing the shortcut.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001398 */
Sunny Goyal95899162019-03-27 16:03:06 -07001399 View createShortcut(WorkspaceItemInfo info) {
Schneider Victor-tulias9f922d32022-04-27 16:39:29 -07001400 // This can be called before PagedView#pageScrollsInitialized returns true, so use the
1401 // first page, which we always assume to be present.
1402 return createShortcut((ViewGroup) mWorkspace.getChildAt(0), info);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001403 }
1404
1405 /**
1406 * Creates a view representing a shortcut inflated from the specified resource.
1407 *
Schneider Victor-tulias9f922d32022-04-27 16:39:29 -07001408 * @param parent The group the shortcut belongs to. This is not necessarily the group where
1409 * the shortcut should be added.
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001410 * @param info The data structure describing the shortcut.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001411 * @return A View inflated from layoutResId.
1412 */
Fengjiang Li080f9322023-07-12 13:33:54 -07001413 public View createShortcut(@Nullable ViewGroup parent, WorkspaceItemInfo info) {
1414 BubbleTextView favorite =
1415 (BubbleTextView) LayoutInflater.from(parent != null ? parent.getContext() : this)
1416 .inflate(R.layout.app_icon, parent, false);
Sunny Goyal95899162019-03-27 16:03:06 -07001417 favorite.applyFromWorkspaceItem(info);
Tracy Zhouba0b5952022-10-14 01:28:07 -07001418 favorite.setOnClickListener(getItemOnClickListener());
Sunny Goyaldcbcc862014-08-12 15:58:36 -07001419 favorite.setOnFocusChangeListener(mFocusHandler);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001420 return favorite;
1421 }
1422
1423 /**
Jon Mirandac476d6e2017-05-04 16:30:01 -07001424 * Add a shortcut to the workspace or to a Folder.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001425 *
1426 * @param data The intent describing the shortcut.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001427 */
sfufa@google.comd0a33232021-09-19 15:59:36 -07001428 protected void completeAddShortcut(Intent data, int container, int screenId, int cellX,
Sunny Goyalfb5096d2016-09-08 14:32:06 -07001429 int cellY, PendingRequestArgs args) {
Holly Sun35b99602023-06-28 15:14:02 -07001430 if (args.getRequestCode() != REQUEST_CREATE_SHORTCUT) {
Sunny Goyalfb5096d2016-09-08 14:32:06 -07001431 return;
1432 }
Adam Cohen558baaf2011-08-15 15:22:57 -07001433
Jon Mirandac476d6e2017-05-04 16:30:01 -07001434 int[] cellXY = mTmpAddItemCellCoordinates;
1435 CellLayout layout = getCellLayout(container, screenId);
1436
Sunny Goyaleaf7a952020-07-29 16:54:20 -07001437 WorkspaceItemInfo info = PinRequestHelper.createWorkspaceItemFromPinItemRequest(
Sunny Goyale7b00122019-10-02 16:13:34 -07001438 this, PinRequestHelper.getPinItemRequest(data), 0);
Sunny Goyal782f0c92017-01-19 10:27:54 -08001439 if (info == null) {
Sunny Goyal84b48d82023-03-29 16:52:27 -07001440 Log.e(TAG, "Unable to parse a valid shortcut result");
1441 return;
Sunny Goyal782f0c92017-01-19 10:27:54 -08001442 }
1443
Jon Mirandac476d6e2017-05-04 16:30:01 -07001444 if (container < 0) {
1445 // Adding a shortcut to the Workspace.
1446 final View view = createShortcut(info);
1447 boolean foundCellSpan = false;
1448 // First we check if we already know the exact location where we want to add this item.
1449 if (cellX >= 0 && cellY >= 0) {
1450 cellXY[0] = cellX;
1451 cellXY[1] = cellY;
1452 foundCellSpan = true;
Adam Cohen558baaf2011-08-15 15:22:57 -07001453
Hyunyoung Song1ae42422020-01-26 23:25:14 -08001454 DragObject dragObject = new DragObject(getApplicationContext());
1455 dragObject.dragInfo = info;
Jon Mirandac476d6e2017-05-04 16:30:01 -07001456 // If appropriate, either create a folder or add to an existing folder
1457 if (mWorkspace.createUserFolderIfNecessary(view, container, layout, cellXY, 0,
Hyunyoung Song1ae42422020-01-26 23:25:14 -08001458 true, dragObject)) {
Jon Mirandac476d6e2017-05-04 16:30:01 -07001459 return;
1460 }
Jon Mirandac476d6e2017-05-04 16:30:01 -07001461 if (mWorkspace.addToExistingFolderIfNecessary(view, layout, cellXY, 0, dragObject,
1462 true)) {
1463 return;
1464 }
1465 } else {
1466 foundCellSpan = layout.findCellForSpan(cellXY, 1, 1);
1467 }
1468
1469 if (!foundCellSpan) {
Yogisha Dixit104d09f2021-07-19 14:05:17 +01001470 mWorkspace.onNoCellFound(layout, info, /* logInstanceId= */ null);
Adam Cohen558baaf2011-08-15 15:22:57 -07001471 return;
1472 }
Jon Mirandac476d6e2017-05-04 16:30:01 -07001473
1474 getModelWriter().addItemToDatabase(info, container, screenId, cellXY[0], cellXY[1]);
1475 mWorkspace.addInScreen(view, info);
Michael Jurkad3ef3062010-11-23 16:23:58 -08001476 } else {
Jon Mirandac476d6e2017-05-04 16:30:01 -07001477 // Adding a shortcut to a Folder.
Sunny Goyale29897f52017-07-20 10:09:42 -07001478 FolderIcon folderIcon = findFolderIcon(container);
Jon Mirandac476d6e2017-05-04 16:30:01 -07001479 if (folderIcon != null) {
1480 FolderInfo folderInfo = (FolderInfo) folderIcon.getTag();
1481 folderInfo.add(info, args.rank, false);
1482 } else {
Sunny Goyale29897f52017-07-20 10:09:42 -07001483 Log.e(TAG, "Could not find folder with id " + container + " to add shortcut.");
Jon Mirandac476d6e2017-05-04 16:30:01 -07001484 }
Michael Jurka0280c3b2010-09-17 15:00:07 -07001485 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001486 }
1487
Tony Wickhamc7cbf252021-05-24 15:46:48 -07001488 @Override
1489 public @Nullable FolderIcon findFolderIcon(final int folderIconId) {
Sunny Goyal83fd25e2018-07-09 16:47:01 -07001490 return (FolderIcon) mWorkspace.getHomescreenIconByItemId(folderIconId);
Sunny Goyale29897f52017-07-20 10:09:42 -07001491 }
1492
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001493 /**
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001494 * Add a widget to the workspace.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001495 *
Romain Guy5bbc91b2010-08-18 11:38:46 -07001496 * @param appWidgetId The app widget id
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001497 */
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001498 @Thunk
1499 void completeAddAppWidget(int appWidgetId, ItemInfo itemInfo,
Adam Cohen59400422014-03-05 18:07:04 -08001500 AppWidgetHostView hostView, LauncherAppWidgetProviderInfo appWidgetInfo) {
1501
Adam Cohened66b2b2012-01-23 17:28:51 -08001502 if (appWidgetInfo == null) {
fbaron30d9e3f2023-08-03 17:03:59 -07001503 appWidgetInfo = mAppWidgetManager.getLauncherAppWidgetInfo(appWidgetId,
1504 itemInfo.getTargetComponent());
Adam Cohened66b2b2012-01-23 17:28:51 -08001505 }
Romain Guycbb89e42009-06-08 15:52:54 -07001506
Yogisha Dixit0b15c7e2021-05-10 12:01:58 +01001507 if (hostView == null) {
1508 // Perform actual inflation because we're live
Sihua Ma0593a0d2022-10-03 16:01:48 -07001509 hostView = mAppWidgetHolder.createView(this, appWidgetId, appWidgetInfo);
Yogisha Dixit0b15c7e2021-05-10 12:01:58 +01001510 }
1511
Adam Cohen59400422014-03-05 18:07:04 -08001512 LauncherAppWidgetInfo launcherInfo;
Yogisha Dixit0b15c7e2021-05-10 12:01:58 +01001513 launcherInfo =
1514 new LauncherAppWidgetInfo(
1515 appWidgetId, appWidgetInfo.provider, appWidgetInfo, hostView);
Sunny Goyal2100c782016-08-22 16:00:03 -07001516 launcherInfo.spanX = itemInfo.spanX;
1517 launcherInfo.spanY = itemInfo.spanY;
1518 launcherInfo.minSpanX = itemInfo.minSpanX;
1519 launcherInfo.minSpanY = itemInfo.minSpanY;
Sunny Goyal952e63d2017-08-16 04:59:08 -07001520 launcherInfo.user = appWidgetInfo.getProfile();
Yogisha Dixit658c5da2021-05-24 23:23:15 +01001521 if (itemInfo instanceof PendingAddWidgetInfo) {
1522 launcherInfo.sourceContainer = ((PendingAddWidgetInfo) itemInfo).sourceContainer;
1523 } else if (itemInfo instanceof PendingRequestArgs) {
1524 launcherInfo.sourceContainer =
1525 ((PendingRequestArgs) itemInfo).getWidgetSourceContainer();
1526 }
Sunny Goyal669b71f2023-01-27 14:37:07 -08001527 CellPos presenterPos = getCellPosMapper().mapModelToPresenter(itemInfo);
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001528 getModelWriter().addItemToDatabase(launcherInfo,
Sunny Goyal669b71f2023-01-27 14:37:07 -08001529 itemInfo.container, presenterPos.screenId, presenterPos.cellX, presenterPos.cellY);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001530
Sunny Goyal2100c782016-08-22 16:00:03 -07001531 hostView.setVisibility(View.VISIBLE);
Sunny Goyald5462aa2016-11-22 16:52:39 +05301532 prepareAppWidget(hostView, launcherInfo);
1533 mWorkspace.addInScreen(hostView, launcherInfo);
Pinyao Tingc9074272019-11-11 11:51:44 -08001534 announceForAccessibility(R.string.item_added_to_workspace);
Yogisha Dixit037a5362021-03-22 14:13:03 +00001535
1536 // Show the widget resize frame.
1537 if (hostView instanceof LauncherAppWidgetHostView) {
1538 final LauncherAppWidgetHostView launcherHostView = (LauncherAppWidgetHostView) hostView;
Sunny Goyal669b71f2023-01-27 14:37:07 -08001539 CellLayout cellLayout = getCellLayout(launcherInfo.container, presenterPos.screenId);
Yogisha Dixit037a5362021-03-22 14:13:03 +00001540 if (mStateManager.getState() == NORMAL) {
Yogisha Dixit7b1d25b2021-10-14 13:06:40 +01001541 AppWidgetResizeFrame.showForWidget(launcherHostView, cellLayout);
Yogisha Dixit037a5362021-03-22 14:13:03 +00001542 } else {
1543 mStateManager.addStateListener(new StateManager.StateListener<LauncherState>() {
1544 @Override
1545 public void onStateTransitionComplete(LauncherState finalState) {
Charlie Anderson438d4052023-04-25 14:38:57 -04001546 if ((mPrevLauncherState == SPRING_LOADED || mPrevLauncherState == EDIT_MODE)
1547 && finalState == NORMAL) {
Yogisha Dixit037a5362021-03-22 14:13:03 +00001548 AppWidgetResizeFrame.showForWidget(launcherHostView, cellLayout);
1549 mStateManager.removeStateListener(this);
1550 }
1551 }
1552 });
1553 }
1554 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001555 }
Romain Guycbb89e42009-06-08 15:52:54 -07001556
Sunny Goyald5462aa2016-11-22 16:52:39 +05301557 private void prepareAppWidget(AppWidgetHostView hostView, LauncherAppWidgetInfo item) {
Sunny Goyal87af0fd2016-05-16 14:56:02 -07001558 hostView.setTag(item);
1559 item.onBindAppWidget(this, hostView);
Sunny Goyal87af0fd2016-05-16 14:56:02 -07001560 hostView.setFocusable(true);
1561 hostView.setOnFocusChangeListener(mFocusHandler);
Sunny Goyal25c2e3e2015-10-28 23:28:21 -07001562 }
1563
Sunny Goyala992ac92023-01-10 17:50:32 -08001564 private final ScreenOnListener mScreenOnListener = this::onScreenOnChanged;
Adam Cohended9f8d2010-11-03 13:25:16 -07001565
Sunny Goyal9c2b9602020-01-07 13:07:55 -08001566 private void updateNotificationDots(Predicate<PackageUserKey> updatedDots) {
Tony Wickhamf34bee82018-12-03 18:11:39 -08001567 mWorkspace.updateNotificationDots(updatedDots);
1568 mAppsView.getAppsStore().updateNotificationDots(updatedDots);
Tony Wickham010d2552017-01-20 08:15:28 -08001569 }
1570
Adam Cohended9f8d2010-11-03 13:25:16 -07001571 @Override
1572 public void onAttachedToWindow() {
1573 super.onAttachedToWindow();
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001574 mOverlayManager.onAttachedToWindow();
Adam Cohended9f8d2010-11-03 13:25:16 -07001575 }
1576
1577 @Override
1578 public void onDetachedFromWindow() {
1579 super.onDetachedFromWindow();
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001580 mOverlayManager.onDetachedFromWindow();
1581 closeContextMenu();
Adam Cohended9f8d2010-11-03 13:25:16 -07001582 }
1583
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -07001584 @Override
1585 public Object onRetainNonConfigurationInstance() {
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08001586 NonConfigInstance instance = new NonConfigInstance();
1587 instance.config = new Configuration(mOldConfig);
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08001588 return instance;
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -07001589 }
1590
Sunny Goyalc4fa8c32017-11-07 12:23:58 -08001591 public AllAppsTransitionController getAllAppsController() {
1592 return mAllAppsController;
1593 }
1594
Sunny Goyal9d69c8d2018-03-19 13:41:31 -07001595 @Override
Winson Chunga6945242014-01-08 14:04:34 -08001596 public DragLayer getDragLayer() {
1597 return mDragLayer;
1598 }
1599
Brian Isganitis1664c9f2022-01-14 23:15:47 -05001600 @Override
1601 public ActivityAllAppsContainerView<Launcher> getAppsView() {
Winson Chungb745afb2015-03-02 11:51:23 -08001602 return mAppsView;
1603 }
1604
Shikha Malhotra0f2e1b62022-03-27 21:02:21 +00001605 public Workspace<?> getWorkspace() {
Winson Chunga6945242014-01-08 14:04:34 -08001606 return mWorkspace;
1607 }
1608
1609 public Hotseat getHotseat() {
1610 return mHotseat;
1611 }
1612
Sunny Goyal7c7be8c2018-03-07 19:58:07 -08001613 public <T extends View> T getOverviewPanel() {
Winson Chung8ae41982017-11-10 11:42:13 -08001614 return (T) mOverviewPanel;
Winson Chunga6945242014-01-08 14:04:34 -08001615 }
1616
Sunny Goyal47328fd2016-05-25 18:56:41 -07001617 public DropTargetBar getDropTargetBar() {
1618 return mDropTargetBar;
Tony Wickham34d2c912015-09-11 09:27:58 -07001619 }
1620
Tony Wickhamb4821882021-04-23 14:26:45 -07001621 @Override
Tony Wickham490a8ab2020-04-01 17:03:58 -07001622 public ScrimView getScrimView() {
1623 return mScrimView;
1624 }
1625
Sihua Ma0593a0d2022-10-03 16:01:48 -07001626 public LauncherWidgetHolder getAppWidgetHolder() {
1627 return mAppWidgetHolder;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001628 }
Romain Guycbb89e42009-06-08 15:52:54 -07001629
Sihua Ma0593a0d2022-10-03 16:01:48 -07001630 protected LauncherWidgetHolder createAppWidgetHolder() {
Sihua Ma1db8bc22022-11-08 17:13:13 -08001631 return LauncherWidgetHolder.HolderFactory.newFactory(this).newInstance(
1632 this, appWidgetId -> getWorkspace().removeWidget(appWidgetId));
Cyrus Boadway0d309db2021-04-14 12:29:14 +00001633 }
1634
Winson Chunga9abd0e2010-10-27 17:18:37 -07001635 public LauncherModel getModel() {
1636 return mModel;
1637 }
1638
Sebastian Francoa64f3a62023-05-05 16:00:32 -06001639 /**
1640 * Returns the ModelWriter writer, make sure to call the function every time you want to use it.
1641 */
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001642 public ModelWriter getModelWriter() {
1643 return mModelWriter;
1644 }
1645
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001646 @Override
Adam Cohen79d90c52016-04-22 13:29:20 -07001647 public SharedPreferences getSharedPrefs() {
Winson Chunga6945242014-01-08 14:04:34 -08001648 return mSharedPrefs;
1649 }
1650
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001651 @Override
1652 public SharedPreferences getDevicePrefs() {
Stefan Andonian146701c2022-11-10 23:07:40 +00001653 return LauncherPrefs.getDevicePrefs(this);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001654 }
1655
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001656 public int getOrientation() {
1657 return mOldConfig.orientation;
1658 }
Jon Miranda6bed3502017-09-19 14:43:17 -07001659
Becky Qiu4ed3dfc2022-10-19 16:58:22 -07001660 public BaseSearchConfig getSearchConfig() {
1661 return mBaseSearchConfig;
Luca Zuccarinibda972b2022-10-03 11:48:27 +00001662 }
1663
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001664 @Override
1665 protected void onNewIntent(Intent intent) {
Brian Isganitisfdd044e2023-03-02 19:45:23 +00001666 if (Utilities.isRunningInTestHarness()) {
vadimtbaf5fbb2019-12-16 18:56:09 -08001667 Log.d(TestProtocol.PERMANENT_DIAG_TAG, "Launcher.onNewIntent: " + intent);
1668 }
Sunny Goyal67736672023-06-02 13:35:19 +00001669 TraceHelper.INSTANCE.beginSection(ON_NEW_INTENT_EVT);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001670 super.onNewIntent(intent);
1671
Sunny Goyalf4aceab2017-12-06 16:16:31 -08001672 boolean alreadyOnHome = hasWindowFocus() && ((intent.getFlags() &
Winson15f8b172015-08-19 11:02:39 -07001673 Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT)
1674 != Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT);
Sunny Goyal85313732016-09-28 12:00:07 -07001675
1676 // Check this condition before handling isActionMain, as this will get reset.
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001677 boolean shouldMoveToDefaultScreen = alreadyOnHome && isInState(NORMAL)
Sunny Goyalf9403d92017-10-18 10:55:56 -07001678 && AbstractFloatingView.getTopOpenView(this) == null;
Winson15f8b172015-08-19 11:02:39 -07001679 boolean isActionMain = Intent.ACTION_MAIN.equals(intent.getAction());
Winson Chung1c2d5222021-06-08 11:50:13 -07001680 boolean internalStateHandled = ACTIVITY_TRACKER.handleNewIntent(this);
kholoud mohamedceec31b2022-02-03 15:44:25 +00001681
Winson15f8b172015-08-19 11:02:39 -07001682 if (isActionMain) {
Sunny Goyald3864fa2017-11-14 15:06:36 -08001683 if (!internalStateHandled) {
Sunny Goyald3864fa2017-11-14 15:06:36 -08001684 // In all these cases, only animate if we're already on home
Schneider Victor-tulias3913e292023-07-21 15:24:57 -07001685 AbstractFloatingView.closeAllOpenViewsExcept(
1686 this, isStarted(), AbstractFloatingView.TYPE_LISTENER);
Jon Mirandafeba90f2016-10-06 10:53:29 -07001687
Sunny Goyala2467272018-03-16 14:53:05 -07001688 if (!isInState(NORMAL)) {
1689 // Only change state, if not already the same. This prevents cancelling any
1690 // animations running as part of resume
Sunny Goyalfee1b252020-12-14 12:30:38 -08001691 mStateManager.goToState(NORMAL, mStateManager.shouldAnimateStateChange());
Sunny Goyala2467272018-03-16 14:53:05 -07001692 }
Sunny Goyald3864fa2017-11-14 15:06:36 -08001693
1694 // Reset the apps view
Sunny Goyal5d1873a2018-05-08 11:10:44 -07001695 if (!alreadyOnHome) {
Sunny Goyal7185dd62018-03-14 17:51:49 -07001696 mAppsView.reset(isStarted() /* animate */);
Sunny Goyald3864fa2017-11-14 15:06:36 -08001697 }
1698
Sunny Goyalaad33592018-08-07 17:20:35 -07001699 if (shouldMoveToDefaultScreen && !mWorkspace.isHandlingTouch()) {
Sunny Goyald3864fa2017-11-14 15:06:36 -08001700 mWorkspace.post(mWorkspace::moveToDefaultScreen);
1701 }
1702 }
Adam Cohen6fecd412013-10-02 17:41:50 -07001703
Adam Cohen9211d422014-10-07 18:14:53 -07001704 if (mLauncherCallbacks != null) {
Sunny Goyal85462132018-04-24 11:39:37 -07001705 mLauncherCallbacks.onHomeIntent(internalStateHandled);
Adam Cohen9211d422014-10-07 18:14:53 -07001706 }
Vinit Nayakf6c2e872023-07-07 13:37:24 -07001707 if (FeatureFlags.ENABLE_SPLIT_FROM_WORKSPACE_TO_WORKSPACE.get()) {
1708 handleSplitAnimationGoingToHome();
1709 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001710 mOverlayManager.hideOverlay(isStarted() && !isForceInvisible());
Sunny Goyal30ac97d2020-06-24 23:47:46 -07001711 handleGestureContract(intent);
Sunny Goyal512a2c12020-04-08 12:52:45 -07001712 } else if (Intent.ACTION_ALL_APPS.equals(intent.getAction())) {
Winson Chungdd15ace2020-08-04 15:52:01 -07001713 showAllAppsFromIntent(alreadyOnHome);
Tracy Zhoucb93ec52023-03-31 22:51:17 -07001714 } else if (INTENT_ACTION_ALL_APPS_TOGGLE.equals(intent.getAction())) {
1715 toggleAllAppsFromIntent(alreadyOnHome);
kholoud mohamedceec31b2022-02-03 15:44:25 +00001716 } else if (Intent.ACTION_SHOW_WORK_APPS.equals(intent.getAction())) {
1717 showAllAppsWorkTabFromIntent(alreadyOnHome);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001718 }
Winson15f8b172015-08-19 11:02:39 -07001719
Sunny Goyal67736672023-06-02 13:35:19 +00001720 TraceHelper.INSTANCE.endSection();
Adam Coppa120b8e2013-11-12 16:26:04 +00001721 }
1722
Vinit Nayakf6c2e872023-07-07 13:37:24 -07001723 /** Handle animating away split placeholder view when user taps on home button */
1724 protected void handleSplitAnimationGoingToHome() {
1725 // Overridden
1726 }
1727
Tracy Zhoucb93ec52023-03-31 22:51:17 -07001728 protected void toggleAllAppsFromIntent(boolean alreadyOnHome) {
1729 if (getStateManager().isInStableState(ALL_APPS)) {
1730 getStateManager().goToState(NORMAL, alreadyOnHome);
1731 } else {
1732 showAllAppsFromIntent(alreadyOnHome);
1733 }
1734 }
1735
Winson Chungdd15ace2020-08-04 15:52:01 -07001736 protected void showAllAppsFromIntent(boolean alreadyOnHome) {
1737 AbstractFloatingView.closeAllOpenViews(this);
1738 getStateManager().goToState(ALL_APPS, alreadyOnHome);
1739 }
1740
kholoud mohamedceec31b2022-02-03 15:44:25 +00001741 private void showAllAppsWorkTabFromIntent(boolean alreadyOnHome) {
1742 showAllAppsFromIntent(alreadyOnHome);
Sunny Goyal34c499d2023-01-24 12:43:18 -08001743 mAppsView.switchToTab(ActivityAllAppsContainerView.AdapterHolder.WORK);
kholoud mohamedceec31b2022-02-03 15:44:25 +00001744 }
1745
Sunny Goyaldeb91c42020-03-24 02:17:59 -07001746 /**
Sunny Goyal30ac97d2020-06-24 23:47:46 -07001747 * Handles gesture nav contract
1748 */
1749 protected void handleGestureContract(Intent intent) {
1750 GestureNavContract gnc = GestureNavContract.fromIntent(intent);
1751 if (gnc != null) {
1752 AbstractFloatingView.closeOpenViews(this, false, TYPE_ICON_SURFACE);
1753 FloatingSurfaceView.show(this, gnc);
1754 }
1755 }
1756
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001757 @Override
Adam Cohen1462de32012-07-24 22:34:36 -07001758 public void onRestoreInstanceState(Bundle state) {
1759 super.onRestoreInstanceState(state);
Andras Kloczl55edfe52021-05-14 12:21:30 +02001760 if (mSynchronouslyBoundPages != null) {
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07001761 mSynchronouslyBoundPages.forEach(screenId -> {
1762 int pageIndex = mWorkspace.getPageIndexForScreenId(screenId);
1763 if (pageIndex != PagedView.INVALID_PAGE) {
1764 mWorkspace.restoreInstanceStateForChild(pageIndex);
1765 }
1766 });
Andras Kloczl55edfe52021-05-14 12:21:30 +02001767 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001768 }
1769
1770 @Override
1771 protected void onSaveInstanceState(Bundle outState) {
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07001772 outState.putIntArray(RUNTIME_STATE_CURRENT_SCREEN_IDS,
1773 mWorkspace.getCurrentPageScreenIds().getArray().toArray());
Sunny Goyalea609262017-10-25 15:47:38 -07001774 outState.putInt(RUNTIME_STATE, mStateManager.getState().ordinal);
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001775
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001776 AbstractFloatingView widgets = AbstractFloatingView
1777 .getOpenView(this, AbstractFloatingView.TYPE_WIDGETS_FULL_SHEET);
1778 if (widgets != null) {
1779 SparseArray<Parcelable> widgetsState = new SparseArray<>();
1780 widgets.saveHierarchyState(widgetsState);
1781 outState.putSparseParcelableArray(RUNTIME_STATE_WIDGET_PANEL, widgetsState);
1782 } else {
1783 outState.remove(RUNTIME_STATE_WIDGET_PANEL);
1784 }
1785
Federico Baron8bf1bca2022-09-27 16:19:11 -07001786 // We close any open folders and shortcut containers that are not safe for rebind,
1787 // and we need to make sure this state is reflected.
1788 AbstractFloatingView.closeAllOpenViewsExcept(
1789 this, isStarted() && !isForceInvisible(), TYPE_REBIND_SAFE);
Pinyao Tinga74b63a2019-07-17 23:26:06 -07001790 finishAutoCancelActionMode();
Tony Wickham49c8d292016-07-01 11:44:34 -07001791
Sunny Goyal2100c782016-08-22 16:00:03 -07001792 if (mPendingRequestArgs != null) {
1793 outState.putParcelable(RUNTIME_STATE_PENDING_REQUEST_ARGS, mPendingRequestArgs);
1794 }
Sunny Goyaldedda052019-05-14 15:23:48 -07001795 outState.putInt(RUNTIME_STATE_PENDING_REQUEST_CODE, mPendingActivityRequestCode);
1796
Sunny Goyal2100c782016-08-22 16:00:03 -07001797 if (mPendingActivityResult != null) {
1798 outState.putParcelable(RUNTIME_STATE_PENDING_ACTIVITY_RESULT, mPendingActivityResult);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001799 }
1800
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001801 super.onSaveInstanceState(outState);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001802 mOverlayManager.onActivitySaveInstanceState(this, outState);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001803 }
1804
1805 @Override
1806 public void onDestroy() {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001807 super.onDestroy();
Sunny Goyale84c5b82019-09-26 17:05:31 -07001808 ACTIVITY_TRACKER.onActivityDestroyed(this);
Romain Guycbb89e42009-06-08 15:52:54 -07001809
Sunny Goyala992ac92023-01-10 17:50:32 -08001810 ScreenOnTracker.INSTANCE.get(this).removeListener(mScreenOnListener);
Sunny Goyalaaf7d1d2016-05-17 13:38:54 -07001811 mWorkspace.removeFolderListeners();
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001812 PluginManagerWrapper.INSTANCE.get(this).removePluginListener(this);
Winson Chunge7a03942011-08-05 15:05:12 -07001813
Sunny Goyala7a5bf32020-01-05 15:35:29 +05301814 mModel.removeCallbacks(this);
Sunny Goyal623eddd2018-03-02 12:24:41 -08001815 mRotationHelper.destroy();
Sunny Goyal745bad92016-05-02 10:54:12 -07001816
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001817 try {
Sihua Ma0593a0d2022-10-03 16:01:48 -07001818 mAppWidgetHolder.stopListening();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001819 } catch (NullPointerException ex) {
Joe Onoratoa30ce8e2009-11-11 08:16:49 -08001820 Log.w(TAG, "problem while stopping AppWidgetHost during Launcher destruction", ex);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001821 }
Sihua Maaa2b8722022-10-25 15:17:58 -07001822 mAppWidgetHolder.destroy();
Patrick Dubroy2313eff2011-01-11 20:01:31 -08001823
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001824 TextKeyListener.getInstance().release();
Tony2917a8b2017-07-31 23:29:42 -07001825 clearPendingBinds();
Hyunyoung Song31971a32019-01-27 12:31:12 -08001826 LauncherAppState.getIDP(this).removeOnChangeListener(this);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001827
1828 mOverlayManager.onActivityDestroyed(this);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001829 }
1830
Sunny Goyalae502842016-06-17 08:43:56 -07001831 public LauncherAccessibilityDelegate getAccessibilityDelegate() {
1832 return mAccessibilityDelegate;
1833 }
1834
Adam Cohena9cf38f2011-05-02 15:36:58 -07001835 public DragController getDragController() {
1836 return mDragController;
1837 }
1838
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001839 @Override
Andrew Cole44898c32023-04-05 13:49:32 -07001840 public DropTargetHandler getDropTargetHandler() {
1841 return new DropTargetHandler(this);
1842 }
1843
1844 @Override
Sunny Goyal0eca4e22016-07-20 11:43:06 -07001845 public void startActivityForResult(Intent intent, int requestCode, Bundle options) {
Sunny Goyaldedda052019-05-14 15:23:48 -07001846 if (requestCode != -1) {
1847 mPendingActivityRequestCode = requestCode;
1848 }
Sunny Goyal210e1742019-10-17 12:05:38 -07001849 super.startActivityForResult(intent, requestCode, options);
Adam Cohen173f7112015-03-27 15:14:00 -07001850 }
1851
1852 @Override
Sunny Goyaldedda052019-05-14 15:23:48 -07001853 public void startIntentSenderForResult(IntentSender intent, int requestCode,
Adam Cohen173f7112015-03-27 15:14:00 -07001854 Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags, Bundle options) {
Sunny Goyaldedda052019-05-14 15:23:48 -07001855 if (requestCode != -1) {
1856 mPendingActivityRequestCode = requestCode;
1857 }
Sunny Goyal210e1742019-10-17 12:05:38 -07001858 try {
1859 super.startIntentSenderForResult(intent, requestCode,
1860 fillInIntent, flagsMask, flagsValues, extraFlags, options);
1861 } catch (IntentSender.SendIntentException e) {
1862 throw new ActivityNotFoundException();
Adam Cohen173f7112015-03-27 15:14:00 -07001863 }
1864 }
1865
Winson Chung70d72102011-08-12 11:24:35 -07001866 /**
1867 * Indicates that we want global search for this activity by setting the globalSearch
1868 * argument for {@link #startSearch} to true.
1869 */
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001870 @Override
Romain Guycbb89e42009-06-08 15:52:54 -07001871 public void startSearch(String initialQuery, boolean selectInitialQuery,
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001872 Bundle appSearchData, boolean globalSearch) {
1873 if (appSearchData == null) {
1874 appSearchData = new Bundle();
Bjorn Bringert32b12d22013-06-06 13:00:41 +01001875 appSearchData.putString("source", "launcher-search");
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001876 }
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07001877
Sunny Goyal6f28e712016-09-13 14:19:29 -07001878 if (mLauncherCallbacks == null ||
1879 !mLauncherCallbacks.startSearch(initialQuery, selectInitialQuery, appSearchData)) {
1880 // Starting search from the callbacks failed. Start the default global search.
Sunny Goyalf4aceab2017-12-06 16:16:31 -08001881 super.startSearch(initialQuery, selectInitialQuery, appSearchData, true);
Ian Parkinson047036e2014-09-01 15:40:53 +01001882 }
Winson Chungcd99cd32015-04-29 11:03:24 -07001883
1884 // We need to show the workspace after starting the search
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001885 mStateManager.goToState(NORMAL);
Bjorn Bringertc459e522013-06-07 19:36:01 +01001886 }
1887
Joe Onorato9c1289c2009-08-17 11:03:03 -04001888 public boolean isWorkspaceLocked() {
Sunny Goyal2100c782016-08-22 16:00:03 -07001889 return mWorkspaceLoading || mPendingRequestArgs != null;
Joe Onorato9c1289c2009-08-17 11:03:03 -04001890 }
1891
Adam Cohen517a7f52014-03-01 12:12:59 -08001892 public boolean isWorkspaceLoading() {
1893 return mWorkspaceLoading;
1894 }
1895
Brian Isganitis099945b2022-01-31 18:15:00 -05001896 @Override
1897 public boolean isBindingItems() {
1898 return mWorkspaceLoading;
1899 }
1900
Anjali Koppalff7ceff2014-05-01 18:26:37 -07001901 private void setWorkspaceLoading(boolean value) {
Anjali Koppalff7ceff2014-05-01 18:26:37 -07001902 mWorkspaceLoading = value;
Anjali Koppalff7ceff2014-05-01 18:26:37 -07001903 }
1904
Sunny Goyal04a324a2017-01-20 21:08:59 -08001905 public void setWaitingForResult(PendingRequestArgs args) {
Sunny Goyal2100c782016-08-22 16:00:03 -07001906 mPendingRequestArgs = args;
Adam Cohen9211d422014-10-07 18:14:53 -07001907 }
Anjali Koppalff7ceff2014-05-01 18:26:37 -07001908
Sunny Goyal2100c782016-08-22 16:00:03 -07001909 void addAppWidgetFromDropImpl(int appWidgetId, ItemInfo info, AppWidgetHostView boundWidget,
Sunny Goyal04a324a2017-01-20 21:08:59 -08001910 WidgetAddFlowHandler addFlowHandler) {
Tony Wickhama0628cc2015-10-14 15:23:04 -07001911 if (LOGD) {
1912 Log.d(TAG, "Adding widget from drop");
1913 }
Sunny Goyal04a324a2017-01-20 21:08:59 -08001914 addAppWidgetImpl(appWidgetId, info, boundWidget, addFlowHandler, 0);
Adam Cohenad4e15c2013-10-17 16:21:35 -07001915 }
1916
Sunny Goyal2100c782016-08-22 16:00:03 -07001917 void addAppWidgetImpl(int appWidgetId, ItemInfo info,
Sunny Goyal04a324a2017-01-20 21:08:59 -08001918 AppWidgetHostView boundWidget, WidgetAddFlowHandler addFlowHandler, int delay) {
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001919 if (!addFlowHandler.startConfigActivity(this, appWidgetId, info,
1920 REQUEST_CREATE_APPWIDGET)) {
Sunny Goyal04a324a2017-01-20 21:08:59 -08001921 // If the configuration flow was not started, add the widget
Michael Jurkaaf442092010-06-10 17:01:57 -07001922
Charlie Anderson438d4052023-04-25 14:38:57 -04001923 // Exit spring loaded mode if necessary after adding the widget
1924 Runnable onComplete = MULTI_SELECT_EDIT_MODE.get() ? null
1925 : () -> mStateManager.goToState(NORMAL, SPRING_LOADED_EXIT_DELAY);
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001926 completeAddAppWidget(appWidgetId, info, boundWidget,
1927 addFlowHandler.getProviderInfo(this));
Sunny Goyal6e379fc2020-03-19 16:08:14 -07001928 mWorkspace.removeExtraEmptyScreenDelayed(delay, false, onComplete);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001929 }
1930 }
Romain Guycbb89e42009-06-08 15:52:54 -07001931
Sunny Goyalefb7e842018-10-04 15:11:00 -07001932 public void addPendingItem(PendingAddItemInfo info, int container, int screenId,
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08001933 int[] cell, int spanX, int spanY) {
Sunny Goyal669b71f2023-01-27 14:37:07 -08001934 if (cell == null) {
1935 CellPos modelPos = getCellPosMapper().mapPresenterToModel(0, 0, screenId, container);
1936 info.screenId = modelPos.screenId;
1937 } else {
1938 CellPos modelPos = getCellPosMapper().mapPresenterToModel(
1939 cell[0], cell[1], screenId, container);
1940 info.screenId = modelPos.screenId;
1941 info.cellX = modelPos.cellX;
1942 info.cellY = modelPos.cellY;
Sunny Goyal2100c782016-08-22 16:00:03 -07001943 }
Sunny Goyal669b71f2023-01-27 14:37:07 -08001944 info.container = container;
Sunny Goyal2100c782016-08-22 16:00:03 -07001945 info.spanX = spanX;
1946 info.spanY = spanY;
1947
Holly Sun35b99602023-06-28 15:14:02 -07001948 if (info instanceof PendingAddWidgetInfo) {
1949 addAppWidgetFromDrop((PendingAddWidgetInfo) info);
1950 } else { // info can only be PendingAddShortcutInfo
1951 processShortcutFromDrop((PendingAddShortcutInfo) info);
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001952 }
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08001953 }
1954
Adam Cohenfbba09b2011-07-18 21:43:05 -07001955 /**
1956 * Process a shortcut drop.
Adam Cohenfbba09b2011-07-18 21:43:05 -07001957 */
Sunny Goyal782f0c92017-01-19 10:27:54 -08001958 private void processShortcutFromDrop(PendingAddShortcutInfo info) {
Sunny Goyalfb5096d2016-09-08 14:32:06 -07001959 Intent intent = new Intent(Intent.ACTION_CREATE_SHORTCUT).setComponent(info.componentName);
1960 setWaitingForResult(PendingRequestArgs.forIntent(REQUEST_CREATE_SHORTCUT, intent, info));
vadimtcf275c12020-04-15 12:43:01 -07001961 TestLogging.recordEvent(TestProtocol.SEQUENCE_MAIN, "start: processShortcutFromDrop");
Sunny Goyal239d6e92023-02-07 13:40:11 -08001962 if (!info.getActivityInfo(this).startConfigActivity(this, REQUEST_CREATE_SHORTCUT)) {
Sunny Goyal782f0c92017-01-19 10:27:54 -08001963 handleActivityResult(REQUEST_CREATE_SHORTCUT, RESULT_CANCELED, null);
1964 }
Michael Jurka0280c3b2010-09-17 15:00:07 -07001965 }
1966
Adam Cohenfbba09b2011-07-18 21:43:05 -07001967 /**
1968 * Process a widget drop.
Adam Cohenfbba09b2011-07-18 21:43:05 -07001969 */
Sunny Goyal2100c782016-08-22 16:00:03 -07001970 private void addAppWidgetFromDrop(PendingAddWidgetInfo info) {
Adam Cohened66b2b2012-01-23 17:28:51 -08001971 AppWidgetHostView hostView = info.boundWidget;
Sunny Goyal952e63d2017-08-16 04:59:08 -07001972 final int appWidgetId;
Sunny Goyal8a0dc382017-01-25 11:30:06 -08001973 WidgetAddFlowHandler addFlowHandler = info.getHandler();
Adam Cohened66b2b2012-01-23 17:28:51 -08001974 if (hostView != null) {
Tony Wickhama0628cc2015-10-14 15:23:04 -07001975 // In the case where we've prebound the widget, we remove it from the DragLayer
1976 if (LOGD) {
1977 Log.d(TAG, "Removing widget view from drag layer and setting boundWidget to null");
1978 }
1979 getDragLayer().removeView(hostView);
1980
Adam Cohened66b2b2012-01-23 17:28:51 -08001981 appWidgetId = hostView.getAppWidgetId();
Sunny Goyal04a324a2017-01-20 21:08:59 -08001982 addAppWidgetFromDropImpl(appWidgetId, info, hostView, addFlowHandler);
Sunny Goyal5b9ebca2015-06-01 18:37:32 -07001983
1984 // Clear the boundWidget so that it doesn't get destroyed.
1985 info.boundWidget = null;
Adam Cohened66b2b2012-01-23 17:28:51 -08001986 } else {
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001987 // In this case, we either need to start an activity to get permission to bind
1988 // the widget, or we need to start an activity to configure the widget, or both.
Pinyao Tingc7a6c292019-08-26 14:36:02 -07001989 if (info.itemType == LauncherSettings.Favorites.ITEM_TYPE_CUSTOM_APPWIDGET) {
fbaron30d9e3f2023-08-03 17:03:59 -07001990 appWidgetId = CustomWidgetManager.INSTANCE.get(this)
1991 .allocateCustomAppWidgetId(info.componentName);
Sunny Goyal952e63d2017-08-16 04:59:08 -07001992 } else {
Sihua Ma0593a0d2022-10-03 16:01:48 -07001993 appWidgetId = getAppWidgetHolder().allocateAppWidgetId();
Sunny Goyal952e63d2017-08-16 04:59:08 -07001994 }
Adam Cohendd70d662012-10-04 16:53:44 -07001995 Bundle options = info.bindOptions;
1996
Sunny Goyalffe83f12014-08-14 17:39:34 -07001997 boolean success = mAppWidgetManager.bindAppWidgetIdIfAllowed(
1998 appWidgetId, info.info, options);
Adam Cohendd70d662012-10-04 16:53:44 -07001999 if (success) {
Sunny Goyal04a324a2017-01-20 21:08:59 -08002000 addAppWidgetFromDropImpl(appWidgetId, info, null, addFlowHandler);
Michael Jurka8b805b12012-04-18 14:23:14 -07002001 } else {
Sunny Goyal04a324a2017-01-20 21:08:59 -08002002 addFlowHandler.startBindFlow(this, appWidgetId, info, REQUEST_BIND_APPWIDGET);
Michael Jurka8b805b12012-04-18 14:23:14 -07002003 }
Adam Cohened66b2b2012-01-23 17:28:51 -08002004 }
Adam Cohenfbba09b2011-07-18 21:43:05 -07002005 }
2006
Samuel Fufa746d4202020-02-02 18:55:44 -08002007 /**
2008 * Creates and adds new folder to CellLayout
2009 */
Samuel Fufa28c3e452020-02-08 16:07:16 -08002010 public FolderIcon addFolder(CellLayout layout, int container, final int screenId, int cellX,
2011 int cellY) {
Michael Jurkac9d95c52011-08-29 14:03:34 -07002012 final FolderInfo folderInfo = new FolderInfo();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002013
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002014 // Update the model
Sunny Goyal43bf11d2017-02-02 13:52:53 -08002015 getModelWriter().addItemToDatabase(folderInfo, container, screenId, cellX, cellY);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002016
2017 // Create the view
Samuel Fufa746d4202020-02-02 18:55:44 -08002018 FolderIcon newFolder = FolderIcon.inflateFolderAndIcon(R.layout.folder_icon, this, layout,
2019 folderInfo);
Sunny Goyald5462aa2016-11-22 16:52:39 +05302020 mWorkspace.addInScreen(newFolder, folderInfo);
Winson Chung5f8afe62013-08-12 16:19:28 -07002021 // Force measure the new folder icon
2022 CellLayout parent = mWorkspace.getParentCellLayoutForView(newFolder);
2023 parent.getShortcutsAndWidgets().measureChild(newFolder);
Adam Cohendf035382011-04-11 17:22:04 -07002024 return newFolder;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002025 }
Romain Guycbb89e42009-06-08 15:52:54 -07002026
Tony Wickham1906cc32021-02-11 11:55:24 -08002027 @Override
2028 public Rect getFolderBoundingBox() {
2029 // We need to bound the folder to the currently visible workspace area
Andras Kloczl3a4ba0b2021-03-29 18:47:14 +02002030 return getWorkspace().getPageAreaRelativeToDragLayer();
Tony Wickham1906cc32021-02-11 11:55:24 -08002031 }
2032
2033 @Override
2034 public void updateOpenFolderPosition(int[] inOutPosition, Rect bounds, int width, int height) {
2035 int left = inOutPosition[0];
2036 int top = inOutPosition[1];
2037 DeviceProfile grid = getDeviceProfile();
2038 int distFromEdgeOfScreen = getWorkspace().getPaddingLeft();
2039 if (grid.isPhone && (grid.availableWidthPx - width) < 4 * distFromEdgeOfScreen) {
2040 // Center the folder if it is very close to being centered anyway, by virtue of
2041 // filling the majority of the viewport. ie. remove it from the uncanny valley
2042 // of centeredness.
2043 left = (grid.availableWidthPx - width) / 2;
2044 } else if (width >= bounds.width()) {
2045 // If the folder doesn't fit within the bounds, center it about the desired bounds
2046 left = bounds.left + (bounds.width() - width) / 2;
2047 }
2048 if (height >= bounds.height()) {
2049 // Folder height is greater than page height, center on page
2050 top = bounds.top + (bounds.height() - height) / 2;
2051 } else {
2052 // Folder height is less than page height, so bound it to the absolute open folder
2053 // bounds if necessary
2054 Rect folderBounds = grid.getAbsoluteOpenFolderBounds();
2055 left = Math.max(folderBounds.left, Math.min(left, folderBounds.right - width));
2056 top = Math.max(folderBounds.top, Math.min(top, folderBounds.bottom - height));
2057 }
2058 inOutPosition[0] = left;
2059 inOutPosition[1] = top;
2060 }
2061
Winsonc0b52fe2015-09-09 16:38:15 -07002062 /**
Winsonfa56b3f2015-09-14 12:01:13 -07002063 * Unbinds the view for the specified item, and removes the item and all its children.
2064 *
2065 * @param v the view being removed.
Winsonfa56b3f2015-09-14 12:01:13 -07002066 * @param itemInfo the {@link ItemInfo} for this view.
2067 * @param deleteFromDb whether or not to delete this item from the db.
Winsonc0b52fe2015-09-09 16:38:15 -07002068 */
Tony Wickhambfbf7f92016-05-19 11:19:39 -07002069 public boolean removeItem(View v, final ItemInfo itemInfo, boolean deleteFromDb) {
Pinyao Ting6a41d562022-05-10 23:47:36 +00002070 return removeItem(v, itemInfo, deleteFromDb, null);
2071 }
2072
2073 /**
2074 * Unbinds the view for the specified item, and removes the item and all its children.
2075 *
2076 * @param v the view being removed.
2077 * @param itemInfo the {@link ItemInfo} for this view.
2078 * @param deleteFromDb whether or not to delete this item from the db.
2079 * @param reason the resaon for removal.
2080 */
2081 public boolean removeItem(View v, final ItemInfo itemInfo, boolean deleteFromDb,
2082 @Nullable final String reason) {
Sunny Goyal95899162019-03-27 16:03:06 -07002083 if (itemInfo instanceof WorkspaceItemInfo) {
Winsonfa56b3f2015-09-14 12:01:13 -07002084 // Remove the shortcut from the folder before removing it from launcher
Sunny Goyal44c06432016-04-02 10:56:02 -07002085 View folderIcon = mWorkspace.getHomescreenIconByItemId(itemInfo.container);
2086 if (folderIcon instanceof FolderIcon) {
Sunny Goyal95899162019-03-27 16:03:06 -07002087 ((FolderInfo) folderIcon.getTag()).remove((WorkspaceItemInfo) itemInfo, true);
Winsonfa56b3f2015-09-14 12:01:13 -07002088 } else {
2089 mWorkspace.removeWorkspaceItem(v);
2090 }
Winsonc0b52fe2015-09-09 16:38:15 -07002091 if (deleteFromDb) {
Pinyao Ting6a41d562022-05-10 23:47:36 +00002092 getModelWriter().deleteItemFromDatabase(itemInfo, reason);
Winsonc0b52fe2015-09-09 16:38:15 -07002093 }
2094 } else if (itemInfo instanceof FolderInfo) {
2095 final FolderInfo folderInfo = (FolderInfo) itemInfo;
Sunny Goyalaaf7d1d2016-05-17 13:38:54 -07002096 if (v instanceof FolderIcon) {
2097 ((FolderIcon) v).removeListeners();
2098 }
Winsonc0b52fe2015-09-09 16:38:15 -07002099 mWorkspace.removeWorkspaceItem(v);
2100 if (deleteFromDb) {
Sunny Goyal43bf11d2017-02-02 13:52:53 -08002101 getModelWriter().deleteFolderAndContentsFromDatabase(folderInfo);
Winsonc0b52fe2015-09-09 16:38:15 -07002102 }
2103 } else if (itemInfo instanceof LauncherAppWidgetInfo) {
2104 final LauncherAppWidgetInfo widgetInfo = (LauncherAppWidgetInfo) itemInfo;
Winson44818e02015-10-02 11:25:46 -07002105 mWorkspace.removeWorkspaceItem(v);
Winsonc0b52fe2015-09-09 16:38:15 -07002106 if (deleteFromDb) {
Sihua Ma0593a0d2022-10-03 16:01:48 -07002107 getModelWriter().deleteWidgetInfo(widgetInfo, getAppWidgetHolder(), reason);
Winsonc0b52fe2015-09-09 16:38:15 -07002108 }
2109 } else {
2110 return false;
2111 }
2112 return true;
2113 }
2114
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002115 @Override
2116 public boolean dispatchKeyEvent(KeyEvent event) {
vadimt6b534ee2021-08-06 15:49:02 -07002117 TestLogging.recordKeyEvent(TestProtocol.SEQUENCE_MAIN, "Key event", event);
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08002118 return (event.getKeyCode() == KeyEvent.KEYCODE_HOME) || super.dispatchKeyEvent(event);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002119 }
2120
Joe Onorato88ec0992009-11-19 13:16:06 -08002121 @Override
vadimt9af34a72020-01-21 11:19:13 -08002122 public boolean dispatchTouchEvent(MotionEvent ev) {
Sunny Goyala306e592020-03-24 01:51:41 -07002123 switch (ev.getAction()) {
2124 case MotionEvent.ACTION_DOWN:
2125 mTouchInProgress = true;
2126 break;
2127 case MotionEvent.ACTION_UP:
Riddle Hsub30adcb2020-10-07 15:57:44 +08002128 mLastTouchUpTime = SystemClock.uptimeMillis();
Sunny Goyala306e592020-03-24 01:51:41 -07002129 // Follow through
2130 case MotionEvent.ACTION_CANCEL:
2131 mTouchInProgress = false;
2132 break;
Sunny Goyal9b180102020-03-11 10:02:29 -07002133 }
vadimtd633c9c2020-01-22 18:00:37 -08002134 TestLogging.recordMotionEvent(TestProtocol.SEQUENCE_MAIN, "Touch event", ev);
vadimt9af34a72020-01-21 11:19:13 -08002135 return super.dispatchTouchEvent(ev);
2136 }
2137
Sunny Goyala306e592020-03-24 01:51:41 -07002138 /**
2139 * Returns true if a touch interaction is in progress
2140 */
2141 public boolean isTouchInProgress() {
2142 return mTouchInProgress;
2143 }
2144
vadimt9af34a72020-01-21 11:19:13 -08002145 @Override
Fengjiang Lib7860bd2023-03-15 10:50:50 -07002146 @TargetApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
Joe Onorato88ec0992009-11-19 13:16:06 -08002147 public void onBackPressed() {
Fengjiang Lib7860bd2023-03-15 10:50:50 -07002148 getOnBackAnimationCallback().onBackInvoked();
Joe Onorato88ec0992009-11-19 13:16:06 -08002149 }
2150
Sunny Goyal3f2637f2022-05-05 12:24:08 -07002151 protected void onStateBack() {
2152 mStateManager.getState().onBackPressed(this);
2153 }
2154
Sunny Goyala992ac92023-01-10 17:50:32 -08002155 protected void onScreenOnChanged(boolean isOn) {
Tracy Zhouf20a4bd2021-04-19 21:37:08 -07002156 // Reset AllApps to its initial state only if we are not in the middle of
2157 // processing a multi-step drop
Sunny Goyala992ac92023-01-10 17:50:32 -08002158 if (!isOn && mPendingRequestArgs == null) {
Tracy Zhouf20a4bd2021-04-19 21:37:08 -07002159 if (!isInState(NORMAL)) {
2160 onUiChangedWhileSleeping();
2161 }
2162 mStateManager.goToState(NORMAL);
2163 }
2164 }
2165
Hyunyoung Song46d07f72018-05-22 15:41:25 -07002166 @Override
Sunny Goyal4fdc9182023-05-12 12:08:53 -07002167 public RunnableList startActivitySafely(View v, Intent intent, ItemInfo item) {
Winson Chung0b70cd42019-06-17 22:34:33 -07002168 if (!hasBeenResumed()) {
Sunny Goyal4fdc9182023-05-12 12:08:53 -07002169 RunnableList result = new RunnableList();
Winson Chung0b70cd42019-06-17 22:34:33 -07002170 // Workaround an issue where the WM launch animation is clobbered when finishing the
2171 // recents animation into launcher. Defer launching the activity until Launcher is
2172 // next resumed.
Sunny Goyal4fdc9182023-05-12 12:08:53 -07002173 addOnResumeCallback(() -> {
2174 RunnableList actualResult = startActivitySafely(v, intent, item);
2175 if (actualResult != null) {
2176 actualResult.add(result::executeAllAndDestroy);
2177 } else {
2178 result.executeAllAndDestroy();
2179 }
2180 });
Winson Chungc9bf6d42019-10-04 15:33:18 -07002181 if (mOnDeferredActivityLaunchCallback != null) {
2182 mOnDeferredActivityLaunchCallback.run();
2183 mOnDeferredActivityLaunchCallback = null;
2184 }
Sunny Goyal4fdc9182023-05-12 12:08:53 -07002185 return result;
Winson Chung0b70cd42019-06-17 22:34:33 -07002186 }
2187
Sunny Goyal4fdc9182023-05-12 12:08:53 -07002188 RunnableList result = super.startActivitySafely(v, intent, item);
2189 if (result != null && v instanceof BubbleTextView) {
Sunny Goyal0b0847b2018-03-14 12:30:11 -07002190 // This is set to the view that launched the activity that navigated the user away
2191 // from launcher. Since there is no callback for when the activity has finished
2192 // launching, enable the press state and keep this reference to reset the press
2193 // state when we return to launcher.
2194 BubbleTextView btv = (BubbleTextView) v;
2195 btv.setStayPressed(true);
Sunny Goyal4fdc9182023-05-12 12:08:53 -07002196 result.add(() -> btv.setStayPressed(false));
Sunny Goyala7ce1662016-05-31 15:01:35 -07002197 }
Sunny Goyal4fdc9182023-05-12 12:08:53 -07002198 return result;
Michael Jurka86a720e2012-05-09 11:23:23 -07002199 }
2200
Winson Chung3d503fb2011-07-13 17:25:49 -07002201 boolean isHotseatLayout(View layout) {
Sunny Goyalc13403c2016-11-18 23:44:48 -08002202 // TODO: Remove this method
Sunny Goyal876e4622018-11-02 13:50:40 -07002203 return mHotseat != null && (layout == mHotseat);
Winson Chung3d503fb2011-07-13 17:25:49 -07002204 }
Romain Guy1fbc1c82009-11-09 20:43:08 -08002205
Winson Chung3d503fb2011-07-13 17:25:49 -07002206 /**
2207 * Returns the CellLayout of the specified container at the specified screen.
fbaron5a7ea302023-07-12 10:16:49 -07002208 *
2209 * @param screenId must be presenterPos and not modelPos.
Winson Chung3d503fb2011-07-13 17:25:49 -07002210 */
Sunny Goyalefb7e842018-10-04 15:11:00 -07002211 public CellLayout getCellLayout(int container, int screenId) {
Sunny Goyal876e4622018-11-02 13:50:40 -07002212 return (container == LauncherSettings.Favorites.CONTAINER_HOTSEAT)
2213 ? mHotseat : mWorkspace.getScreenWithId(screenId);
Romain Guya6abce82009-11-10 02:54:41 -08002214 }
2215
Michael Jurkae326f182011-11-21 14:05:46 -08002216 @Override
2217 public void onTrimMemory(int level) {
2218 super.onTrimMemory(level);
Adam Cohen3f9c9712014-10-31 11:48:25 -07002219 if (level >= ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN) {
2220 // The widget preview db can result in holding onto over
2221 // 3MB of memory for caching which isn't necessary.
2222 SQLiteDatabase.releaseMemory();
2223
Adam Cohenc8f4e1b2014-11-19 16:03:20 -08002224 // This clears all widget bitmaps from the widget tray
Hyunyoung Song3f471442015-04-08 19:01:34 -07002225 // TODO(hyunyoungs)
Michael Jurkae326f182011-11-21 14:05:46 -08002226 }
2227 }
2228
Michael Jurkad7c28052012-04-27 15:43:36 -07002229 @Override
2230 public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
alanv1d4fde62012-10-17 13:15:47 -07002231 final boolean result = super.dispatchPopulateAccessibilityEvent(event);
Michael Jurkad7c28052012-04-27 15:43:36 -07002232 final List<CharSequence> text = event.getText();
2233 text.clear();
alanv1d4fde62012-10-17 13:15:47 -07002234 // Populate event with a fake title based on the current state.
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07002235 // TODO: When can workspace be null?
2236 text.add(mWorkspace == null
Sunny Goyal52e25452020-07-20 12:38:01 -07002237 ? getString(R.string.home_screen)
Sunny Goyalea609262017-10-25 15:47:38 -07002238 : mStateManager.getState().getDescription(this));
Michael Jurkad7c28052012-04-27 15:43:36 -07002239 return result;
2240 }
2241
Michael Jurka7607c2f2013-04-03 14:33:19 -07002242 /**
Winson Chungc9bf6d42019-10-04 15:33:18 -07002243 * Persistant callback which notifies when an activity launch is deferred because the activity
2244 * was not yet resumed.
2245 */
2246 public void setOnDeferredActivityLaunchCallback(Runnable callback) {
2247 mOnDeferredActivityLaunchCallback = callback;
2248 }
2249
2250 /**
Andras Kloczl55edfe52021-05-14 12:21:30 +02002251 * Sets the next pages to bind synchronously on next bind.
2252 * @param pages should not be null.
Sunny Goyala7a5bf32020-01-05 15:35:29 +05302253 */
Andras Kloczl55edfe52021-05-14 12:21:30 +02002254 public void setPagesToBindSynchronously(@NonNull IntSet pages) {
2255 mPagesToBindSynchronously = pages;
Sunny Goyala7a5bf32020-01-05 15:35:29 +05302256 }
2257
Sunny Goyal93f878c2016-03-30 17:31:24 -07002258 @Override
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002259 public IntSet getPagesToBindSynchronously(IntArray orderedScreenIds) {
Alex Chau49354042021-08-25 13:21:58 +01002260 IntSet visibleIds;
2261 if (!mPagesToBindSynchronously.isEmpty()) {
2262 visibleIds = mPagesToBindSynchronously;
2263 } else if (!mWorkspaceLoading) {
2264 visibleIds = mWorkspace.getCurrentPageScreenIds();
2265 } else {
2266 // If workspace binding is still in progress, getCurrentPageScreenIds won't be accurate,
2267 // and we should use mSynchronouslyBoundPages that's set during initial binding.
2268 visibleIds = mSynchronouslyBoundPages;
2269 }
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002270 IntArray actualIds = new IntArray();
2271
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002272 IntSet result = new IntSet();
2273 if (visibleIds.isEmpty()) {
2274 return result;
2275 }
2276 for (int id : orderedScreenIds.toArray()) {
Alex Chau1e448462021-08-13 21:48:35 +01002277 actualIds.add(id);
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002278 }
2279 int firstId = visibleIds.getArray().get(0);
Steven Ng4b346102021-09-14 19:17:09 +01002280 int pairId = mWorkspace.getScreenPair(firstId);
Alex Chau62f129b2021-09-03 16:54:27 +01002281 // Double check that actual screenIds contains the visibleId, as empty screens are hidden
2282 // in single panel.
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002283 if (actualIds.contains(firstId)) {
2284 result.add(firstId);
Alex Chau62f129b2021-09-03 16:54:27 +01002285 if (mDeviceProfile.isTwoPanels && actualIds.contains(pairId)) {
2286 result.add(pairId);
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002287 }
Alex Chau62f129b2021-09-03 16:54:27 +01002288 } else if (LauncherAppState.getIDP(this).supportedProfiles.stream().anyMatch(
2289 deviceProfile -> deviceProfile.isTwoPanels) && actualIds.contains(pairId)) {
2290 // Add the right panel if left panel is hidden when switching display, due to empty
2291 // pages being hidden in single panel.
2292 result.add(pairId);
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002293 }
2294 return result;
Joe Onorato9c1289c2009-08-17 11:03:03 -04002295 }
The Android Open Source Projectf96811c2009-03-18 17:39:48 -07002296
Joe Onorato9c1289c2009-08-17 11:03:03 -04002297 /**
Sunny Goyal527c7d32015-08-28 15:19:36 -07002298 * Clear any pending bind callbacks. This is called when is loader is planning to
2299 * perform a full rebind from scratch.
2300 */
2301 @Override
2302 public void clearPendingBinds() {
Sunny Goyal527c7d32015-08-28 15:19:36 -07002303 if (mPendingExecutor != null) {
Sunny Goyal4a48a982021-06-17 15:15:46 -07002304 mPendingExecutor.cancel();
Sunny Goyal527c7d32015-08-28 15:19:36 -07002305 mPendingExecutor = null;
Sunny Goyal6b6d0a32019-08-05 17:19:32 -07002306
2307 // We might have set this flag previously and forgot to clear it.
2308 mAppsView.getAppsStore()
2309 .disableDeferUpdatesSilently(AllAppsStore.DEFER_UPDATES_NEXT_DRAW);
Sunny Goyal527c7d32015-08-28 15:19:36 -07002310 }
2311 }
2312
2313 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04002314 * Refreshes the shortcuts shown on the workspace.
Schneider Victor-tuliasfff7cef2023-04-10 15:59:23 -07002315 * <p>
Joe Onorato9c1289c2009-08-17 11:03:03 -04002316 * Implementation of the method from LauncherModel.Callbacks.
2317 */
2318 public void startBinding() {
Sunny Goyal67736672023-06-02 13:35:19 +00002319 TraceHelper.INSTANCE.beginSection("startBinding");
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07002320 // Floating panels (except the full widget sheet) are associated with individual icons. If
2321 // we are starting a fresh bind, close all such panels as all the icons are about
2322 // to go away.
Pinyao Tinga74b63a2019-07-17 23:26:06 -07002323 AbstractFloatingView.closeOpenViews(this, true, TYPE_ALL & ~TYPE_REBIND_SAFE);
Jon Miranda6dc7f1e2017-02-21 12:37:51 -08002324
Anjali Koppalff7ceff2014-05-01 18:26:37 -07002325 setWorkspaceLoading(true);
Adam Cohen517a7f52014-03-01 12:12:59 -08002326
Winson Chungd64d1762013-08-20 14:37:16 -07002327 // Clear the workspace because it's going to be rebound
Sunny Goyal2db53422019-03-01 16:06:12 -08002328 mDragController.cancelDrag();
2329
Adam Cohendf035382011-04-11 17:22:04 -07002330 mWorkspace.clearDropTargets();
Winson Chung9e6a0a22013-08-27 11:58:12 -07002331 mWorkspace.removeAllWorkspaceScreens();
Sihua Ma0593a0d2022-10-03 16:01:48 -07002332 mAppWidgetHolder.clearViews();
Winson Chungd64d1762013-08-20 14:37:16 -07002333
Winson Chung3d503fb2011-07-13 17:25:49 -07002334 if (mHotseat != null) {
Sunny Goyalc4d32012020-04-03 17:10:11 -07002335 mHotseat.resetLayout(getDeviceProfile().isVerticalBarLayout());
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002336 }
Sunny Goyal67736672023-06-02 13:35:19 +00002337 TraceHelper.INSTANCE.endSection();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002338 }
2339
Adam Cohendcd297f2013-06-18 13:13:40 -07002340 @Override
Sunny Goyalefb7e842018-10-04 15:11:00 -07002341 public void bindScreens(IntArray orderedScreenIds) {
fbaronc7a605e2023-08-10 23:39:56 -07002342 mWorkspace.mPageIndicator.setAreScreensBinding(true);
Alex Chau1e448462021-08-13 21:48:35 +01002343 int firstScreenPosition = 0;
Jon Miranda7143ba62019-03-15 09:00:05 -07002344 if (FeatureFlags.QSB_ON_FIRST_SCREEN &&
Andras Kloczldbf577a2021-05-26 15:02:52 +02002345 orderedScreenIds.indexOf(Workspace.FIRST_SCREEN_ID) != firstScreenPosition) {
Sunny Goyalefb7e842018-10-04 15:11:00 -07002346 orderedScreenIds.removeValue(Workspace.FIRST_SCREEN_ID);
Andras Kloczldbf577a2021-05-26 15:02:52 +02002347 orderedScreenIds.add(firstScreenPosition, Workspace.FIRST_SCREEN_ID);
Jon Miranda7143ba62019-03-15 09:00:05 -07002348 } else if (!FeatureFlags.QSB_ON_FIRST_SCREEN && orderedScreenIds.isEmpty()) {
Sunny Goyala9e2f5a2016-06-10 12:22:04 -07002349 // If there are no screens, we need to have an empty screen
Andras Kloczl408a54f2021-08-28 00:59:08 +01002350 mWorkspace.addExtraEmptyScreens();
Adam Cohen5084cba2013-09-03 12:01:16 -07002351 }
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002352 bindAddScreens(orderedScreenIds);
Winson Chung0e6a7132013-08-23 12:55:10 -07002353
Winsonc7d2e832016-07-28 12:24:55 -07002354 // After we have added all the screens, if the wallpaper was locked to the default state,
2355 // then notify to indicate that it can be released and a proper wallpaper offset can be
2356 // computed before the next layout
2357 mWorkspace.unlockWallpaperFromDefaultPageOnNextLayout();
Winson Chung64359a52013-07-08 17:17:08 -07002358 }
2359
Sebastian Francoddd04502023-07-26 15:09:10 -07002360 /**
2361 * Remove odd number because they are already included when isTwoPanels and add the pair screen
2362 * if not present.
2363 */
2364 private IntArray filterTwoPanelScreenIds(IntArray orderedScreenIds) {
2365 IntSet screenIds = IntSet.wrap(orderedScreenIds);
2366 orderedScreenIds.forEach(screenId -> {
2367 if (screenId % 2 == 1) {
2368 screenIds.remove(screenId);
2369 // In case the pair is not added, add it
2370 if (!mWorkspace.containsScreenId(screenId - 1)) {
2371 screenIds.add(screenId - 1);
2372 }
2373 }
2374 });
2375 return screenIds.getArray();
2376 }
2377
Sunny Goyalefb7e842018-10-04 15:11:00 -07002378 private void bindAddScreens(IntArray orderedScreenIds) {
Sebastian Francoddd04502023-07-26 15:09:10 -07002379
Andras Kloczl8c574de2021-08-17 23:12:17 +02002380 if (mDeviceProfile.isTwoPanels) {
Sebastian Francoddd04502023-07-26 15:09:10 -07002381 if (FOLDABLE_SINGLE_PAGE.get()) {
2382 orderedScreenIds = filterTwoPanelScreenIds(orderedScreenIds);
2383 } else {
2384 // Some empty pages might have been removed while the phone was in a single panel
2385 // mode, so we want to add those empty pages back.
2386 IntSet screenIds = IntSet.wrap(orderedScreenIds);
2387 orderedScreenIds.forEach(
2388 screenId -> screenIds.add(mWorkspace.getScreenPair(screenId)));
2389 orderedScreenIds = screenIds.getArray();
2390 }
Andras Kloczl8c574de2021-08-17 23:12:17 +02002391 }
2392
Adam Cohendcd297f2013-06-18 13:13:40 -07002393 int count = orderedScreenIds.size();
2394 for (int i = 0; i < count; i++) {
Sunny Goyalefb7e842018-10-04 15:11:00 -07002395 int screenId = orderedScreenIds.get(i);
Andras Kloczldbf577a2021-05-26 15:02:52 +02002396 if (FeatureFlags.QSB_ON_FIRST_SCREEN && screenId == Workspace.FIRST_SCREEN_ID) {
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002397 // No need to bind the first screen, as its always bound.
Andras Kloczldbf577a2021-05-26 15:02:52 +02002398 continue;
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002399 }
Andras Kloczldbf577a2021-05-26 15:02:52 +02002400 mWorkspace.insertNewWorkspaceScreenBeforeEmptyScreen(screenId);
Adam Cohendcd297f2013-06-18 13:13:40 -07002401 }
Adam Cohendcd297f2013-06-18 13:13:40 -07002402 }
2403
Sunny Goyalb23980c2017-08-17 07:45:25 -07002404 @Override
Tony Wickham6a71a5b2018-08-21 11:40:23 -07002405 public void preAddApps() {
2406 // If there's an undo snackbar, force it to complete to ensure empty screens are removed
2407 // before trying to add new items.
2408 mModelWriter.commitDelete();
2409 AbstractFloatingView snackbar = AbstractFloatingView.getOpenView(this, TYPE_SNACKBAR);
2410 if (snackbar != null) {
2411 snackbar.post(() -> snackbar.close(true));
2412 }
2413 }
2414
2415 @Override
Sunny Goyalefb7e842018-10-04 15:11:00 -07002416 public void bindAppsAdded(IntArray newScreens, ArrayList<ItemInfo> addNotAnimated,
Sunny Goyal29947f02017-12-18 13:49:44 -08002417 ArrayList<ItemInfo> addAnimated) {
Winson Chungd64d1762013-08-20 14:37:16 -07002418 // Add the new screens
Adam Cohen76a47a12014-02-05 11:47:43 -08002419 if (newScreens != null) {
Alex Chau817e0fa2021-09-08 20:46:32 +01002420 // newScreens can contain an empty right panel that is already bound, but not known
2421 // by BgDataModel.
2422 newScreens.removeAllValues(mWorkspace.mScreenOrder);
Adam Cohen76a47a12014-02-05 11:47:43 -08002423 bindAddScreens(newScreens);
2424 }
Winson Chungd64d1762013-08-20 14:37:16 -07002425
2426 // We add the items without animation on non-visible pages, and with
2427 // animations on the new page (which we will try and snap to).
Adam Cohen76a47a12014-02-05 11:47:43 -08002428 if (addNotAnimated != null && !addNotAnimated.isEmpty()) {
Sunny Goyalb23980c2017-08-17 07:45:25 -07002429 bindItems(addNotAnimated, false);
Winson Chungd64d1762013-08-20 14:37:16 -07002430 }
Adam Cohen76a47a12014-02-05 11:47:43 -08002431 if (addAnimated != null && !addAnimated.isEmpty()) {
Sunny Goyalb23980c2017-08-17 07:45:25 -07002432 bindItems(addAnimated, true);
Winson Chungd64d1762013-08-20 14:37:16 -07002433 }
Winson Chungc58497e2013-09-03 17:48:37 -07002434
Winson Chung87412982013-10-03 18:34:14 -07002435 // Remove the extra empty screen
Sunny Goyal6e379fc2020-03-19 16:08:14 -07002436 mWorkspace.removeExtraEmptyScreen(false);
Winson Chungd64d1762013-08-20 14:37:16 -07002437 }
2438
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002439 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04002440 * Bind the items start-end from the list.
2441 *
2442 * Implementation of the method from LauncherModel.Callbacks.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002443 */
Tony Wickham0bb211a2015-10-02 16:22:08 -07002444 @Override
Sunny Goyalb23980c2017-08-17 07:45:25 -07002445 public void bindItems(final List<ItemInfo> items, final boolean forceAnimateIcons) {
Schneider Victor-tulias68706eb2021-04-29 15:24:54 -07002446 bindItems(items, forceAnimateIcons, /* focusFirstItemForAccessibility= */ false);
2447 }
2448
2449
2450 /**
2451 * Bind the items start-end from the list.
2452 *
2453 * Implementation of the method from LauncherModel.Callbacks.
2454 *
2455 * @param focusFirstItemForAccessibility true iff the first item to be added to the workspace
2456 * should be focused for accessibility.
2457 */
2458 public void bindItems(
2459 final List<ItemInfo> items,
2460 final boolean forceAnimateIcons,
2461 final boolean focusFirstItemForAccessibility) {
Sunny Goyal3be633b2016-12-08 09:59:25 -08002462 // Get the list of added items and intersect them with the set of items here
Rajeev Kumar43c0f582017-06-23 15:34:55 -07002463 final Collection<Animator> bounceAnims = new ArrayList<>();
Schneider Victor-tulias68fb4162021-09-16 13:24:01 -07002464 boolean canAnimatePageChange = canAnimatePageChange();
Shikha Malhotraf78da1b2022-04-11 10:23:18 +00002465 Workspace<?> workspace = mWorkspace;
Sunny Goyalefb7e842018-10-04 15:11:00 -07002466 int newItemsScreenId = -1;
Sunny Goyalb23980c2017-08-17 07:45:25 -07002467 int end = items.size();
Schneider Victor-tulias68706eb2021-04-29 15:24:54 -07002468 View newView = null;
Sunny Goyalb23980c2017-08-17 07:45:25 -07002469 for (int i = 0; i < end; i++) {
Sunny Goyal3be633b2016-12-08 09:59:25 -08002470 final ItemInfo item = items.get(i);
Winson Chung4d279d92011-07-21 11:46:32 -07002471
2472 // Short circuit if we are loading dock items for a configuration which has no dock
2473 if (item.container == LauncherSettings.Favorites.CONTAINER_HOTSEAT &&
2474 mHotseat == null) {
2475 continue;
2476 }
2477
Sunny Goyal639e9062015-08-19 19:17:06 -07002478 final View view;
Joe Onorato9c1289c2009-08-17 11:03:03 -04002479 switch (item.itemType) {
2480 case LauncherSettings.Favorites.ITEM_TYPE_APPLICATION:
Sunny Goyal3be633b2016-12-08 09:59:25 -08002481 case LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT: {
Sunny Goyal95899162019-03-27 16:03:06 -07002482 WorkspaceItemInfo info = (WorkspaceItemInfo) item;
Sunny Goyal639e9062015-08-19 19:17:06 -07002483 view = createShortcut(info);
Joe Onorato9c1289c2009-08-17 11:03:03 -04002484 break;
Sunny Goyal3be633b2016-12-08 09:59:25 -08002485 }
2486 case LauncherSettings.Favorites.ITEM_TYPE_FOLDER: {
Tracy Zhou4d7b2442019-12-09 13:42:57 -08002487 view = FolderIcon.inflateFolderAndIcon(R.layout.folder_icon, this,
Michael Jurka0142d492010-08-25 17:46:15 -07002488 (ViewGroup) workspace.getChildAt(workspace.getCurrentPage()),
Sunny Goyal1cd01b02016-11-09 10:43:58 -08002489 (FolderInfo) item);
Joe Onorato9c1289c2009-08-17 11:03:03 -04002490 break;
Sunny Goyal3be633b2016-12-08 09:59:25 -08002491 }
Jeremy Sim7cf0dd92023-03-24 22:39:45 -07002492 case LauncherSettings.Favorites.ITEM_TYPE_APP_PAIR: {
Jeremy Sim94fd07e2023-04-19 20:56:49 -07002493 view = AppPairIcon.inflateIcon(R.layout.app_pair_icon, this,
2494 (ViewGroup) workspace.getChildAt(workspace.getCurrentPage()),
2495 (FolderInfo) item);
Jeremy Sim7cf0dd92023-03-24 22:39:45 -07002496 break;
2497 }
Sunny Goyal952e63d2017-08-16 04:59:08 -07002498 case LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET:
2499 case LauncherSettings.Favorites.ITEM_TYPE_CUSTOM_APPWIDGET: {
Sunny Goyala9a1a212017-08-18 01:03:21 -07002500 view = inflateAppWidget((LauncherAppWidgetInfo) item);
Sunny Goyalb23980c2017-08-17 07:45:25 -07002501 if (view == null) {
2502 continue;
Sunny Goyal3be633b2016-12-08 09:59:25 -08002503 }
Sunny Goyal3be633b2016-12-08 09:59:25 -08002504 break;
2505 }
Winson Chungc763c4e2013-07-19 13:49:06 -07002506 default:
2507 throw new RuntimeException("Invalid Item Type");
Joe Onorato9c1289c2009-08-17 11:03:03 -04002508 }
Sunny Goyal639e9062015-08-19 19:17:06 -07002509
Samuel Fufaca37b8a2019-08-19 17:04:36 -07002510 /*
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002511 * Remove colliding items.
2512 */
Sunny Goyal669b71f2023-01-27 14:37:07 -08002513 CellPos presenterPos = getCellPosMapper().mapModelToPresenter(item);
2514 if (item.container == CONTAINER_DESKTOP) {
2515 CellLayout cl = mWorkspace.getScreenWithId(presenterPos.screenId);
2516 if (cl != null && cl.isOccupied(presenterPos.cellX, presenterPos.cellY)) {
2517 View v = cl.getChildAt(presenterPos.cellX, presenterPos.cellY);
Jon Miranda0aff1152021-11-05 16:36:07 -07002518 if (v == null) {
2519 Log.e(TAG, "bindItems failed when removing colliding item=" + item);
2520 }
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002521 Object tag = v.getTag();
2522 String desc = "Collision while binding workspace item: " + item
2523 + ". Collides with " + tag;
Zak Cohen3eeb41d2020-02-14 14:15:13 -08002524 if (FeatureFlags.IS_STUDIO_BUILD) {
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002525 throw (new RuntimeException(desc));
2526 } else {
Pinyao Ting6a41d562022-05-10 23:47:36 +00002527 getModelWriter().deleteItemFromDatabase(item, desc);
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002528 continue;
2529 }
2530 }
2531 }
Sunny Goyald5462aa2016-11-22 16:52:39 +05302532 workspace.addInScreenFromBind(view, item);
Schneider Victor-tulias68fb4162021-09-16 13:24:01 -07002533 if (forceAnimateIcons) {
Sunny Goyal639e9062015-08-19 19:17:06 -07002534 // Animate all the applications up now
2535 view.setAlpha(0f);
2536 view.setScaleX(0f);
2537 view.setScaleY(0f);
2538 bounceAnims.add(createNewAppBounceAnimation(view, i));
Sunny Goyal669b71f2023-01-27 14:37:07 -08002539 newItemsScreenId = presenterPos.screenId;
Sunny Goyal639e9062015-08-19 19:17:06 -07002540 }
Schneider Victor-tulias68706eb2021-04-29 15:24:54 -07002541
2542 if (newView == null) {
2543 newView = view;
2544 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002545 }
Winson Chungf0c6ae02012-03-21 16:10:31 -07002546
Schneider Victor-tulias68706eb2021-04-29 15:24:54 -07002547 View viewToFocus = newView;
2548 // Animate to the correct pager
Schneider Victor-tulias68fb4162021-09-16 13:24:01 -07002549 if (forceAnimateIcons && newItemsScreenId > -1) {
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002550 AnimatorSet anim = new AnimatorSet();
2551 anim.playTogether(bounceAnims);
Schneider Victor-tulias68706eb2021-04-29 15:24:54 -07002552 if (focusFirstItemForAccessibility && viewToFocus != null) {
2553 anim.addListener(new AnimatorListenerAdapter() {
2554 @Override
2555 public void onAnimationEnd(Animator animation) {
2556 viewToFocus.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_FOCUSED);
2557 }
2558 });
2559 }
Jon Miranda64eb8ea2018-03-29 11:43:58 -07002560
Sunny Goyalefb7e842018-10-04 15:11:00 -07002561 int currentScreenId = mWorkspace.getScreenIdForPageIndex(mWorkspace.getNextPage());
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002562 final int newScreenIndex = mWorkspace.getPageIndexForScreenId(newItemsScreenId);
2563 final Runnable startBounceAnimRunnable = anim::start;
2564
Schneider Victor-tulias68fb4162021-09-16 13:24:01 -07002565 if (canAnimatePageChange && newItemsScreenId != currentScreenId) {
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002566 // We post the animation slightly delayed to prevent slowdowns
2567 // when we are loading right after we return to launcher.
2568 mWorkspace.postDelayed(new Runnable() {
2569 public void run() {
2570 if (mWorkspace != null) {
Andy Wickham65ced1b2020-03-07 02:14:19 +00002571 closeOpenViews(false);
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002572
2573 mWorkspace.snapToPage(newScreenIndex);
2574 mWorkspace.postDelayed(startBounceAnimRunnable,
2575 NEW_APPS_ANIMATION_DELAY);
Winson Chung94d67682013-09-25 16:29:40 -07002576 }
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002577 }
2578 }, NEW_APPS_PAGE_MOVE_DELAY);
2579 } else {
2580 mWorkspace.postDelayed(startBounceAnimRunnable, NEW_APPS_ANIMATION_DELAY);
Winson Chung997a9232013-07-24 15:33:46 -07002581 }
Schneider Victor-tulias68706eb2021-04-29 15:24:54 -07002582 } else if (focusFirstItemForAccessibility && viewToFocus != null) {
2583 viewToFocus.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_FOCUSED);
Winson Chung64359a52013-07-08 17:17:08 -07002584 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04002585 workspace.requestLayout();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002586 }
2587
Joe Onorato9c1289c2009-08-17 11:03:03 -04002588 /**
2589 * Add the views for a widget to the workspace.
Joe Onorato9c1289c2009-08-17 11:03:03 -04002590 */
Sunny Goyala9a1a212017-08-18 01:03:21 -07002591 public void bindAppWidget(LauncherAppWidgetInfo item) {
2592 View view = inflateAppWidget(item);
2593 if (view != null) {
2594 mWorkspace.addInScreen(view, item);
2595 mWorkspace.requestLayout();
2596 }
2597 }
2598
2599 private View inflateAppWidget(LauncherAppWidgetInfo item) {
Samuel Fufaca37b8a2019-08-19 17:04:36 -07002600 if (item.hasOptionFlag(LauncherAppWidgetInfo.OPTION_SEARCH_WIDGET)) {
2601 item.providerName = QsbContainerView.getSearchComponentName(this);
2602 if (item.providerName == null) {
Pinyao Ting6a41d562022-05-10 23:47:36 +00002603 getModelWriter().deleteItemFromDatabase(item,
2604 "search widget removed because search component cannot be found");
Samuel Fufaca37b8a2019-08-19 17:04:36 -07002605 return null;
2606 }
2607 }
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002608 final AppWidgetHostView view;
Sunny Goyal2e1efb42016-03-03 16:58:55 -08002609 if (mIsSafeModeEnabled) {
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002610 view = new PendingAppWidgetHostView(this, item, mIconCache, true);
Sunny Goyald5462aa2016-11-22 16:52:39 +05302611 prepareAppWidget(view, item);
Sunny Goyalb23980c2017-08-17 07:45:25 -07002612 return view;
Sunny Goyal2e1efb42016-03-03 16:58:55 -08002613 }
2614
Sunny Goyal67736672023-06-02 13:35:19 +00002615 TraceHelper.INSTANCE.beginSection("BIND_WIDGET_id=" + item.appWidgetId);
Joe Onorato9c1289c2009-08-17 11:03:03 -04002616
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002617 try {
2618 final LauncherAppWidgetProviderInfo appWidgetInfo;
Steven Ngacd9d792021-06-25 11:51:44 +01002619 String removalReason = "";
Adam Cohen59400422014-03-05 18:07:04 -08002620
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002621 if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY)) {
2622 // If the provider is not ready, bind as a pending widget.
2623 appWidgetInfo = null;
Steven Ngacd9d792021-06-25 11:51:44 +01002624 removalReason = "the provider isn't ready.";
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002625 } else if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)) {
2626 // The widget id is not valid. Try to find the widget based on the provider info.
2627 appWidgetInfo = mAppWidgetManager.findProvider(item.providerName, item.user);
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002628 if (appWidgetInfo == null) {
2629 if (WidgetsModel.GO_DISABLE_WIDGETS) {
Steven Ngacd9d792021-06-25 11:51:44 +01002630 removalReason = "widgets are disabled on go device.";
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002631 } else {
Steven Ngacd9d792021-06-25 11:51:44 +01002632 removalReason =
2633 "WidgetManagerHelper cannot find a provider from provider info.";
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002634 }
2635 }
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002636 } else {
fbaron30d9e3f2023-08-03 17:03:59 -07002637 appWidgetInfo = mAppWidgetManager.getLauncherAppWidgetInfo(item.appWidgetId,
2638 item.getTargetComponent());
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002639 if (appWidgetInfo == null) {
fbaron30d9e3f2023-08-03 17:03:59 -07002640 if (item.appWidgetId <= CUSTOM_WIDGET_ID) {
Steven Ngacd9d792021-06-25 11:51:44 +01002641 removalReason =
2642 "CustomWidgetManager cannot find provider from that widget id.";
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002643 } else {
Steven Ngacd9d792021-06-25 11:51:44 +01002644 removalReason = "AppWidgetManager cannot find provider for that widget id."
2645 + " It could be because AppWidgetService is not available, or the"
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002646 + " appWidgetId has not been bound to a the provider yet, or you"
2647 + " don't have access to that appWidgetId.";
2648 }
2649 }
Sunny Goyalff572272014-07-23 13:58:07 -07002650 }
Sunny Goyalff572272014-07-23 13:58:07 -07002651
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002652 // If the provider is ready, but the width is not yet restored, try to restore it.
2653 if (!item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY)
2654 && (item.restoreStatus != LauncherAppWidgetInfo.RESTORE_COMPLETED)) {
2655 if (appWidgetInfo == null) {
Pinyao Ting6a41d562022-05-10 23:47:36 +00002656 getModelWriter().deleteItemFromDatabase(item,
2657 "Removing restored widget: id=" + item.appWidgetId
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002658 + " belongs to component " + item.providerName + " user " + item.user
Steven Ngacd9d792021-06-25 11:51:44 +01002659 + ", as the provider is null and " + removalReason);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002660 return null;
2661 }
Sunny Goyalff572272014-07-23 13:58:07 -07002662
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002663 // If we do not have a valid id, try to bind an id.
2664 if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)) {
2665 if (!item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_ALLOCATED)) {
2666 // Id has not been allocated yet. Allocate a new id.
Sihua Ma0593a0d2022-10-03 16:01:48 -07002667 item.appWidgetId = mAppWidgetHolder.allocateAppWidgetId();
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002668 item.restoreStatus |= LauncherAppWidgetInfo.FLAG_ID_ALLOCATED;
Sunny Goyal86df1382016-08-10 15:03:22 -07002669
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002670 // Also try to bind the widget. If the bind fails, the user will be shown
2671 // a click to setup UI, which will ask for the bind permission.
Yogisha Dixit658c5da2021-05-24 23:23:15 +01002672 PendingAddWidgetInfo pendingInfo =
2673 new PendingAddWidgetInfo(appWidgetInfo, item.sourceContainer);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002674 pendingInfo.spanX = item.spanX;
2675 pendingInfo.spanY = item.spanY;
2676 pendingInfo.minSpanX = item.minSpanX;
2677 pendingInfo.minSpanY = item.minSpanY;
Sunny Goyal19ff7282021-04-22 10:12:54 -07002678 Bundle options = pendingInfo.getDefaultSizeOptions(this);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002679
2680 boolean isDirectConfig =
2681 item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_DIRECT_CONFIG);
2682 if (isDirectConfig && item.bindOptions != null) {
2683 Bundle newOptions = item.bindOptions.getExtras();
2684 if (options != null) {
2685 newOptions.putAll(options);
2686 }
2687 options = newOptions;
Sunny Goyal86df1382016-08-10 15:03:22 -07002688 }
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002689 boolean success = mAppWidgetManager.bindAppWidgetIdIfAllowed(
2690 item.appWidgetId, appWidgetInfo, options);
2691
2692 // We tried to bind once. If we were not able to bind, we would need to
2693 // go through the permission dialog, which means we cannot skip the config
2694 // activity.
2695 item.bindOptions = null;
2696 item.restoreStatus &= ~LauncherAppWidgetInfo.FLAG_DIRECT_CONFIG;
2697
2698 // Bind succeeded
2699 if (success) {
2700 // If the widget has a configure activity, it is still needs to set it
2701 // up, otherwise the widget is ready to go.
2702 item.restoreStatus = (appWidgetInfo.configure == null) || isDirectConfig
2703 ? LauncherAppWidgetInfo.RESTORE_COMPLETED
2704 : LauncherAppWidgetInfo.FLAG_UI_NOT_READY;
2705 }
2706
2707 getModelWriter().updateItemInDatabase(item);
Sunny Goyal86df1382016-08-10 15:03:22 -07002708 }
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002709 } else if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_UI_NOT_READY)
2710 && (appWidgetInfo.configure == null)) {
2711 // The widget was marked as UI not ready, but there is no configure activity to
2712 // update the UI.
2713 item.restoreStatus = LauncherAppWidgetInfo.RESTORE_COMPLETED;
Sunny Goyal43bf11d2017-02-02 13:52:53 -08002714 getModelWriter().updateItemInDatabase(item);
Sunny Goyalff572272014-07-23 13:58:07 -07002715 }
Samuel Fufa9151c012020-02-24 17:06:28 -08002716 else if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_UI_NOT_READY)
2717 && appWidgetInfo.configure != null) {
2718 if (mAppWidgetManager.isAppWidgetRestored(item.appWidgetId)) {
2719 item.restoreStatus = LauncherAppWidgetInfo.RESTORE_COMPLETED;
2720 getModelWriter().updateItemInDatabase(item);
2721 }
2722 }
Sunny Goyal56c73602015-09-25 12:55:01 -07002723 }
2724
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002725 if (item.restoreStatus == LauncherAppWidgetInfo.RESTORE_COMPLETED) {
2726 // Verify that we own the widget
2727 if (appWidgetInfo == null) {
Pinyao Ting0d97f8d2020-12-04 15:12:26 -08002728 FileLog.e(TAG, "Removing invalid widget: id=" + item.appWidgetId);
Sihua Ma0593a0d2022-10-03 16:01:48 -07002729 getModelWriter().deleteWidgetInfo(item, getAppWidgetHolder(), removalReason);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002730 return null;
2731 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04002732
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002733 item.minSpanX = appWidgetInfo.minSpanX;
2734 item.minSpanY = appWidgetInfo.minSpanY;
Sihua Ma0593a0d2022-10-03 16:01:48 -07002735 view = mAppWidgetHolder.createView(this, item.appWidgetId, appWidgetInfo);
Samuel Fufa9151c012020-02-24 17:06:28 -08002736 } else if (!item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)
2737 && appWidgetInfo != null) {
Sihua Ma0593a0d2022-10-03 16:01:48 -07002738 mAppWidgetHolder.addPendingView(item.appWidgetId,
Samuel Fufa9151c012020-02-24 17:06:28 -08002739 new PendingAppWidgetHostView(this, item, mIconCache, false));
Sihua Ma0593a0d2022-10-03 16:01:48 -07002740 view = mAppWidgetHolder.createView(this, item.appWidgetId, appWidgetInfo);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002741 } else {
2742 view = new PendingAppWidgetHostView(this, item, mIconCache, false);
2743 }
2744 prepareAppWidget(view, item);
2745 } finally {
Sunny Goyal67736672023-06-02 13:35:19 +00002746 TraceHelper.INSTANCE.endSection();
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002747 }
2748
Sunny Goyalb23980c2017-08-17 07:45:25 -07002749 return view;
Joe Onorato9c1289c2009-08-17 11:03:03 -04002750 }
2751
Sunny Goyalff572272014-07-23 13:58:07 -07002752 /**
2753 * Restores a pending widget.
2754 *
2755 * @param appWidgetId The app widget id
Sunny Goyalff572272014-07-23 13:58:07 -07002756 */
Sunny Goyald478c832016-04-01 12:04:16 -07002757 private LauncherAppWidgetInfo completeRestoreAppWidget(int appWidgetId, int finalRestoreFlag) {
Sunny Goyalff572272014-07-23 13:58:07 -07002758 LauncherAppWidgetHostView view = mWorkspace.getWidgetForAppWidgetId(appWidgetId);
2759 if ((view == null) || !(view instanceof PendingAppWidgetHostView)) {
2760 Log.e(TAG, "Widget update called, when the widget no longer exists.");
Sunny Goyald478c832016-04-01 12:04:16 -07002761 return null;
Sunny Goyalff572272014-07-23 13:58:07 -07002762 }
2763
Sunny Goyal0fc1be12014-08-11 17:05:23 -07002764 LauncherAppWidgetInfo info = (LauncherAppWidgetInfo) view.getTag();
Sunny Goyald478c832016-04-01 12:04:16 -07002765 info.restoreStatus = finalRestoreFlag;
Jon Miranda2b823f42017-05-02 18:36:18 -07002766 if (info.restoreStatus == LauncherAppWidgetInfo.RESTORE_COMPLETED) {
2767 info.pendingItemInfo = null;
2768 }
Sunny Goyalff572272014-07-23 13:58:07 -07002769
Sunny Goyalba47faa2017-10-04 16:50:57 -07002770 if (((PendingAppWidgetHostView) view).isReinflateIfNeeded()) {
Sunny Goyal29947f02017-12-18 13:49:44 -08002771 view.reInflate();
Sunny Goyalba47faa2017-10-04 16:50:57 -07002772 }
2773
Sunny Goyal43bf11d2017-02-02 13:52:53 -08002774 getModelWriter().updateItemInDatabase(info);
Sunny Goyald478c832016-04-01 12:04:16 -07002775 return info;
Sunny Goyalff572272014-07-23 13:58:07 -07002776 }
2777
Sunny Goyal527c7d32015-08-28 15:19:36 -07002778 public void clearPendingExecutor(ViewOnDrawExecutor executor) {
2779 if (mPendingExecutor == executor) {
2780 mPendingExecutor = null;
2781 }
2782 }
2783
Sunny Goyalb5b9ad62016-04-02 11:23:39 -07002784 @Override
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -07002785 @TargetApi(Build.VERSION_CODES.S)
Fengjiang Li5a36c172023-04-13 18:18:27 +00002786 public void onInitialBindComplete(IntSet boundPages, RunnableList pendingTasks,
2787 int workspaceItemCount, boolean isBindSync) {
Sunny Goyal4a48a982021-06-17 15:15:46 -07002788 mSynchronouslyBoundPages = boundPages;
Sunny Goyal4a48a982021-06-17 15:15:46 -07002789 mPagesToBindSynchronously = new IntSet();
2790
2791 clearPendingBinds();
2792 ViewOnDrawExecutor executor = new ViewOnDrawExecutor(pendingTasks);
2793 mPendingExecutor = executor;
2794 if (!isInState(ALL_APPS)) {
2795 mAppsView.getAppsStore().enableDeferUpdates(AllAppsStore.DEFER_UPDATES_NEXT_DRAW);
2796 pendingTasks.add(() -> mAppsView.getAppsStore().disableDeferUpdates(
2797 AllAppsStore.DEFER_UPDATES_NEXT_DRAW));
2798 }
2799
Sunny Goyal7b8d63f2022-04-14 16:37:32 -07002800 if (mOnInitialBindListener != null) {
2801 getRootView().getViewTreeObserver().removeOnPreDrawListener(mOnInitialBindListener);
2802 mOnInitialBindListener = null;
Sunny Goyalb5b9ad62016-04-02 11:23:39 -07002803 }
Sunny Goyal7b8d63f2022-04-14 16:37:32 -07002804
2805 executor.onLoadAnimationCompleted();
Sunny Goyal4a48a982021-06-17 15:15:46 -07002806 executor.attachTo(this);
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -07002807 if (Utilities.ATLEAST_S) {
2808 Trace.endAsyncSection(DISPLAY_WORKSPACE_TRACE_METHOD_NAME,
2809 DISPLAY_WORKSPACE_TRACE_COOKIE);
2810 }
Fengjiang Li5a36c172023-04-13 18:18:27 +00002811 mStartupLatencyLogger
2812 .logCardinality(workspaceItemCount)
2813 .logEnd(isBindSync
2814 ? LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_SYNC
2815 : LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_ASYNC);
2816 // In the first rootview's onDraw after onInitialBindComplete(), log end of startup latency.
2817 getRootView().getViewTreeObserver().addOnDrawListener(
2818 new ViewTreeObserver.OnDrawListener() {
2819
2820 @Override
2821 public void onDraw() {
2822 mStartupLatencyLogger
2823 .logEnd(LAUNCHER_LATENCY_STARTUP_TOTAL_DURATION)
2824 .log()
2825 .reset();
2826 MAIN_EXECUTOR.getHandler().postAtFrontOfQueue(
2827 () -> getRootView().getViewTreeObserver()
2828 .removeOnDrawListener(this));
2829 }
2830 });
Sunny Goyalb5b9ad62016-04-02 11:23:39 -07002831 }
2832
Joe Onorato9c1289c2009-08-17 11:03:03 -04002833 /**
2834 * Callback saying that there aren't any more items to bind.
Schneider Victor-tuliasfff7cef2023-04-10 15:59:23 -07002835 * <p>
Joe Onorato9c1289c2009-08-17 11:03:03 -04002836 * Implementation of the method from LauncherModel.Callbacks.
2837 */
Andras Kloczl55edfe52021-05-14 12:21:30 +02002838 public void finishBindingItems(IntSet pagesBoundFirst) {
Sunny Goyal67736672023-06-02 13:35:19 +00002839 TraceHelper.INSTANCE.beginSection("finishBindingItems");
Adam Cohen1462de32012-07-24 22:34:36 -07002840 mWorkspace.restoreInstanceStateForRemainingPages();
Joe Onorato9c1289c2009-08-17 11:03:03 -04002841
Anjali Koppalff7ceff2014-05-01 18:26:37 -07002842 setWorkspaceLoading(false);
Adam Cohendb364c32014-05-20 14:23:40 -07002843
Sunny Goyal2100c782016-08-22 16:00:03 -07002844 if (mPendingActivityResult != null) {
2845 handleActivityResult(mPendingActivityResult.requestCode,
2846 mPendingActivityResult.resultCode, mPendingActivityResult.data);
2847 mPendingActivityResult = null;
Adam Cohendb364c32014-05-20 14:23:40 -07002848 }
2849
Andras Kloczl55edfe52021-05-14 12:21:30 +02002850 int currentPage = pagesBoundFirst != null && !pagesBoundFirst.isEmpty()
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002851 ? mWorkspace.getPageIndexForScreenId(pagesBoundFirst.getArray().get(0))
2852 : PagedView.INVALID_PAGE;
Tonyf80e8932018-12-21 11:58:04 -08002853 // When undoing the removal of the last item on a page, return to that page.
Tony Wickham03f27012019-04-25 14:22:54 -07002854 // Since we are just resetting the current page without user interaction,
2855 // override the previous page so we don't log the page switch.
Andras Kloczl55edfe52021-05-14 12:21:30 +02002856 mWorkspace.setCurrentPage(currentPage, currentPage /* overridePrevPage */);
2857 mPagesToBindSynchronously = new IntSet();
Tony Wickham6a71a5b2018-08-21 11:40:23 -07002858
Sunny Goyalac6f69f2019-08-16 11:59:55 -07002859 // Cache one page worth of icons
2860 getViewCache().setCacheSize(R.layout.folder_application,
2861 mDeviceProfile.inv.numFolderColumns * mDeviceProfile.inv.numFolderRows);
2862 getViewCache().setCacheSize(R.layout.folder_page, 2);
2863
Sunny Goyal67736672023-06-02 13:35:19 +00002864 TraceHelper.INSTANCE.endSection();
fbaronc7a605e2023-08-10 23:39:56 -07002865 mWorkspace.removeExtraEmptyScreen(/* stripEmptyScreens= */ true);
2866 mWorkspace.mPageIndicator.setAreScreensBinding(false);
Winson Chungf0c6ae02012-03-21 16:10:31 -07002867 }
2868
Schneider Victor-tulias68fb4162021-09-16 13:24:01 -07002869 private boolean canAnimatePageChange() {
Sunny Goyal9b180102020-03-11 10:02:29 -07002870 if (mDragController.isDragging()) {
2871 return false;
2872 } else {
Riddle Hsu979da642020-09-22 21:52:40 +08002873 return (SystemClock.uptimeMillis() - mLastTouchUpTime)
Sunny Goyal9b180102020-03-11 10:02:29 -07002874 > (NEW_APPS_ANIMATION_INACTIVE_TIMEOUT_SECONDS * 1000);
2875 }
Winson Chunga2413752012-04-03 14:22:34 -07002876 }
2877
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002878 /**
2879 * Similar to {@link #getFirstMatch} but optimized to finding a suitable view for the app close
2880 * animation.
2881 *
2882 * @param preferredItemId The id of the preferred item to match to if it exists.
2883 * @param packageName The package name of the app to match.
2884 * @param user The user of the app to match.
Jon Mirandab42e1242022-03-08 16:37:35 -08002885 * @param supportsAllAppsState If true and we are in All Apps state, looks for view in All Apps.
2886 * Else we only looks on the workspace.
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002887 */
Jon Mirandaf58db152022-06-02 16:06:37 -07002888 public @Nullable View getFirstMatchForAppClose(int preferredItemId, String packageName,
2889 UserHandle user, boolean supportsAllAppsState) {
Sunny Goyal32084d42022-05-02 10:00:07 -07002890 final Predicate<ItemInfo> preferredItem = info ->
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002891 info != null && info.id == preferredItemId;
Sunny Goyal32084d42022-05-02 10:00:07 -07002892 final Predicate<ItemInfo> packageAndUserAndApp = info ->
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002893 info != null
2894 && info.itemType == ITEM_TYPE_APPLICATION
2895 && info.user.equals(user)
2896 && info.getTargetComponent() != null
2897 && TextUtils.equals(info.getTargetComponent().getPackageName(),
2898 packageName);
2899
Jon Mirandab42e1242022-03-08 16:37:35 -08002900 if (supportsAllAppsState && isInState(LauncherState.ALL_APPS)) {
Jon Mirandaf58db152022-06-02 16:06:37 -07002901 AllAppsRecyclerView activeRecyclerView = mAppsView.getActiveRecyclerView();
2902 View v = getFirstMatch(Collections.singletonList(activeRecyclerView),
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002903 preferredItem, packageAndUserAndApp);
Jon Mirandaf58db152022-06-02 16:06:37 -07002904
Sunny Goyalf34811d2022-10-21 20:42:34 +00002905 if (v != null && activeRecyclerView.computeVerticalScrollOffset() > 0) {
Jon Mirandaf58db152022-06-02 16:06:37 -07002906 RectF locationBounds = new RectF();
2907 FloatingIconView.getLocationBoundsForView(this, v, false, locationBounds,
2908 new Rect());
2909 if (locationBounds.top < mAppsView.getHeaderBottom()) {
2910 // Icon is covered by scrim, return null to play fallback animation.
2911 return null;
2912 }
2913 }
2914
2915 return v;
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002916 }
Federico Baron8bf1bca2022-09-27 16:19:11 -07002917
2918 // Look for the item inside the folder at the current page
2919 Folder folder = Folder.getOpen(this);
2920 if (folder != null) {
2921 View v = getFirstMatch(Collections.singletonList(
2922 folder.getContent().getCurrentCellLayout().getShortcutsAndWidgets()),
2923 preferredItem,
2924 packageAndUserAndApp);
2925 if (v == null) {
2926 folder.close(isStarted() && !isForceInvisible());
2927 } else {
2928 return v;
2929 }
2930 }
2931
2932 List<ViewGroup> containers = new ArrayList<>(mWorkspace.getPanelCount() + 1);
2933 containers.add(mWorkspace.getHotseat().getShortcutsAndWidgets());
2934 mWorkspace.forEachVisiblePage(page
2935 -> containers.add(((CellLayout) page).getShortcutsAndWidgets()));
2936
2937 // Order: Preferred item by itself or in folder, then by matching package/user
2938 return getFirstMatch(containers, preferredItem, forFolderMatch(preferredItem),
2939 packageAndUserAndApp, forFolderMatch(packageAndUserAndApp));
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002940 }
2941
2942 /**
2943 * Finds the first view matching the ordered operators across the given viewgroups in order.
2944 * @param containers List of ViewGroups to scan, in order of preference.
2945 * @param operators List of operators, in order starting from best matching operator.
2946 */
Jon Mirandaf26bdcb2022-06-09 16:09:30 -07002947 @Nullable
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002948 private static View getFirstMatch(Iterable<ViewGroup> containers,
Sunny Goyal32084d42022-05-02 10:00:07 -07002949 final Predicate<ItemInfo>... operators) {
2950 for (Predicate<ItemInfo> operator : operators) {
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002951 for (ViewGroup container : containers) {
2952 View match = mapOverViewGroup(container, operator);
2953 if (match != null) {
2954 return match;
2955 }
2956 }
2957 }
2958 return null;
2959 }
2960
2961 /**
2962 * Returns the first view matching the operator in the given ViewGroups, or null if none.
2963 * Forward iteration matters.
2964 */
Jon Mirandaf26bdcb2022-06-09 16:09:30 -07002965 @Nullable
Sunny Goyal32084d42022-05-02 10:00:07 -07002966 private static View mapOverViewGroup(ViewGroup container, Predicate<ItemInfo> op) {
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002967 final int itemCount = container.getChildCount();
2968 for (int itemIdx = 0; itemIdx < itemCount; itemIdx++) {
2969 View item = container.getChildAt(itemIdx);
Sunny Goyal32084d42022-05-02 10:00:07 -07002970 if (op.test((ItemInfo) item.getTag())) {
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002971 return item;
2972 }
2973 }
2974 return null;
2975 }
2976
Winson Chungc9168342013-06-26 14:54:55 -07002977 private ValueAnimator createNewAppBounceAnimation(View v, int i) {
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002978 ValueAnimator bounceAnim = new PropertyListBuilder().alpha(1).scale(1).build(v)
Sunny Goyal60e68c92020-08-12 13:59:27 -07002979 .setDuration(ItemInstallQueue.NEW_SHORTCUT_BOUNCE_DURATION);
2980 bounceAnim.setStartDelay(i * ItemInstallQueue.NEW_SHORTCUT_STAGGER_DELAY);
Sunny Goyal5a1f53b2015-05-27 10:24:24 -07002981 bounceAnim.setInterpolator(new OvershootInterpolator(BOUNCE_ANIMATION_TENSION));
Winson Chungc9168342013-06-26 14:54:55 -07002982 return bounceAnim;
2983 }
2984
Pinyao Tingc9074272019-11-11 11:51:44 -08002985 private void announceForAccessibility(@StringRes int stringResId) {
2986 getDragLayer().announceForAccessibility(getString(stringResId));
2987 }
2988
Amith Yamasani6d7fe502010-11-16 09:05:07 -08002989 /**
Josh Tsuji231c9222022-01-11 20:43:59 -05002990 * Informs us that the overlay (-1 screen, typically), has either become visible or invisible.
2991 */
Sunny Goyal82379182022-11-02 18:58:49 -07002992 public void onOverlayVisibilityChanged(boolean visible) {
2993 getStatsLogManager().logger()
2994 .withSrcState(LAUNCHER_STATE_HOME)
2995 .withDstState(LAUNCHER_STATE_HOME)
2996 .withContainerInfo(LauncherAtom.ContainerInfo.newBuilder()
2997 .setWorkspace(WorkspaceContainer.newBuilder()
2998 .setPageIndex(visible ? 0 : -1))
2999 .build())
3000 .log(visible ? LAUNCHER_SWIPELEFT : LAUNCHER_SWIPERIGHT);
3001 }
Josh Tsuji231c9222022-01-11 20:43:59 -05003002
3003 /**
3004 * Informs us that the page transition has ended, so that we can react to the newly selected
3005 * page if we want to.
3006 */
3007 public void onPageEndTransition() {}
3008
3009 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04003010 * Add the icons for all apps.
3011 *
3012 * Implementation of the method from LauncherModel.Callbacks.
3013 */
Sunny Goyal28daf4a2020-06-08 17:06:09 -07003014 @Override
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -07003015 @TargetApi(Build.VERSION_CODES.S)
Anushree Ganjam97434ee2023-05-18 22:03:16 +00003016 @UiThread
3017 public void bindAllApplications(AppInfo[] apps, int flags,
3018 Map<PackageUserKey, Integer> packageUserKeytoUidMap) {
3019 Preconditions.assertUIThread();
Sunny Goyalc80e60d2023-06-07 12:52:30 -07003020 boolean hadWorkApps = mAppsView.shouldShowTabs();
Brian Isganitise9eacb32023-07-06 22:25:18 +00003021 AllAppsStore<Launcher> appsStore = mAppsView.getAppsStore();
Anushree Ganjam97434ee2023-05-18 22:03:16 +00003022 appsStore.setApps(apps, flags, packageUserKeytoUidMap);
Sunny Goyal1818fb72020-11-09 14:32:48 -08003023 PopupContainerWithArrow.dismissInvalidPopup(this);
Sunny Goyalc80e60d2023-06-07 12:52:30 -07003024 if (hadWorkApps != mAppsView.shouldShowTabs()) {
3025 getStateManager().goToState(NORMAL);
3026 }
3027
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -07003028 if (Utilities.ATLEAST_S) {
3029 Trace.endAsyncSection(DISPLAY_ALL_APPS_TRACE_METHOD_NAME,
3030 DISPLAY_ALL_APPS_TRACE_COOKIE);
3031 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04003032 }
3033
3034 /**
Zak Cohen658c67a2018-10-19 14:21:05 -07003035 * Copies LauncherModel's map of activities to shortcut counts to Launcher's. This is necessary
Tony Wickhambfbf7f92016-05-19 11:19:39 -07003036 * because LauncherModel's map is updated in the background, while Launcher runs on the UI.
3037 */
3038 @Override
Zak Cohen658c67a2018-10-19 14:21:05 -07003039 public void bindDeepShortcutMap(HashMap<ComponentKey, Integer> deepShortcutMapCopy) {
Tony Wickham010d2552017-01-20 08:15:28 -08003040 mPopupDataProvider.setDeepShortcutMap(deepShortcutMapCopy);
Tony Wickham1bce7fd2016-04-28 17:39:03 -07003041 }
3042
Sunny Goyal4390ace2014-10-13 11:33:11 -07003043 @Override
Schneider Victor-tulias6a5f4312021-01-12 19:30:02 +00003044 public void bindIncrementalDownloadProgressUpdated(AppInfo app) {
3045 mAppsView.getAppsStore().updateProgressBar(app);
Mario Bertschler08ffaae2017-03-20 11:30:27 -07003046 }
3047
3048 @Override
Sunny Goyal29947f02017-12-18 13:49:44 -08003049 public void bindWidgetsRestored(ArrayList<LauncherAppWidgetInfo> widgets) {
Sunny Goyal4390ace2014-10-13 11:33:11 -07003050 mWorkspace.widgetsRestored(widgets);
3051 }
3052
Joe Onorato9c1289c2009-08-17 11:03:03 -04003053 /**
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07003054 * Some shortcuts were updated in the background.
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07003055 * Implementation of the method from LauncherModel.Callbacks.
Sunny Goyald3b87ef2016-07-28 12:11:54 -07003056 *
3057 * @param updated list of shortcuts which have changed.
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07003058 */
Sunny Goyal4390ace2014-10-13 11:33:11 -07003059 @Override
Sunny Goyal28f50752020-07-21 14:15:13 -07003060 public void bindWorkspaceItemsChanged(List<WorkspaceItemInfo> updated) {
Sunny Goyal4390ace2014-10-13 11:33:11 -07003061 if (!updated.isEmpty()) {
Sunny Goyal711c5962021-06-23 12:36:18 -07003062 mWorkspace.updateWorkspaceItems(updated, this);
Sunny Goyal1818fb72020-11-09 14:32:48 -08003063 PopupContainerWithArrow.dismissInvalidPopup(this);
Sunny Goyal4390ace2014-10-13 11:33:11 -07003064 }
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07003065 }
3066
3067 /**
Chris Wrenaeff7ea2014-02-14 16:59:24 -05003068 * Update the state of a package, typically related to install state.
3069 *
3070 * Implementation of the method from LauncherModel.Callbacks.
3071 */
Sunny Goyale755d462014-07-22 13:48:29 -07003072 @Override
Sunny Goyal29947f02017-12-18 13:49:44 -08003073 public void bindRestoreItemsChange(HashSet<ItemInfo> updates) {
Sunny Goyal711c5962021-06-23 12:36:18 -07003074 mWorkspace.updateRestoreItems(updates, this);
Sunny Goyala22666f2014-09-18 13:25:15 -07003075 }
3076
3077 /**
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07003078 * A package was uninstalled/updated. We take both the super set of packageNames
Winson Chung83892cc2013-05-01 16:53:33 -07003079 * in addition to specific applications to remove, the reason being that
3080 * this can be called when a package is updated as well. In that scenario,
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07003081 * we only remove specific components from the workspace and hotseat, where as
Winson Chung83892cc2013-05-01 16:53:33 -07003082 * package-removal should clear all items by package name.
Joe Onorato9c1289c2009-08-17 11:03:03 -04003083 */
Sunny Goyal1a745e82014-10-02 15:58:31 -07003084 @Override
Sunny Goyal32084d42022-05-02 10:00:07 -07003085 public void bindWorkspaceComponentsRemoved(Predicate<ItemInfo> matcher) {
Sunny Goyal6e13dd32017-08-17 03:01:19 -07003086 mWorkspace.removeItemsByMatcher(matcher);
3087 mDragController.onAppsRemoved(matcher);
Sunny Goyal1818fb72020-11-09 14:32:48 -08003088 PopupContainerWithArrow.dismissInvalidPopup(this);
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07003089 }
Sunny Goyal4390ace2014-10-13 11:33:11 -07003090
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07003091 @Override
Steven Ng2f5648a2021-02-08 17:18:25 +00003092 public void bindAllWidgets(final List<WidgetsListBaseEntry> allWidgets) {
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07003093 mPopupDataProvider.setAllWidgets(allWidgets);
Tony Wickham26b17462017-03-20 17:12:24 -07003094 }
3095
kholoud mohamedc76b2032021-12-20 16:47:38 +00003096 @Override
3097 public void bindStringCache(StringCache cache) {
3098 mStringCache = cache;
Brandon Dayauon076dcdf2023-06-08 13:52:06 -07003099 mAppsView.updateWorkUI();
kholoud mohamedc76b2032021-12-20 16:47:38 +00003100 }
3101
3102 @Override
3103 public StringCache getStringCache() {
3104 return mStringCache;
3105 }
3106
Tony Wickham86222d22017-03-29 15:30:43 -07003107 /**
3108 * @param packageUser if null, refreshes all widgets and shortcuts, otherwise only
3109 * refreshes the widgets and shortcuts associated with the given package/user
3110 */
3111 public void refreshAndBindWidgetsForPackageUser(@Nullable PackageUserKey packageUser) {
Sunny Goyalc6e97692017-06-02 13:46:55 -07003112 mModel.refreshAndBindWidgetsAndShortcuts(packageUser);
Sunny Goyal2e1efb42016-03-03 16:58:55 -08003113 }
3114
Winson Chung80baf5a2010-08-09 16:03:15 -07003115 /**
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08003116 * $ adb shell dumpsys activity com.android.launcher3.Launcher [--all]
Joe Onoratobe386092009-11-17 17:32:16 -08003117 */
Adam Cohen16d7ffc2011-10-05 17:49:14 -07003118 @Override
3119 public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) {
3120 super.dump(prefix, fd, writer, args);
Sunny Goyala1365452015-10-01 15:46:24 -07003121
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08003122 if (args.length > 0 && TextUtils.equals(args[0], "--all")) {
3123 writer.println(prefix + "Workspace Items");
Sunny Goyal7ce471b2017-08-02 03:37:39 -07003124 for (int i = 0; i < mWorkspace.getPageCount(); i++) {
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08003125 writer.println(prefix + " Homescreen " + i);
3126
3127 ViewGroup layout = ((CellLayout) mWorkspace.getPageAt(i)).getShortcutsAndWidgets();
3128 for (int j = 0; j < layout.getChildCount(); j++) {
3129 Object tag = layout.getChildAt(j).getTag();
3130 if (tag != null) {
3131 writer.println(prefix + " " + tag.toString());
3132 }
3133 }
3134 }
3135
3136 writer.println(prefix + " Hotseat");
Sunny Goyal876e4622018-11-02 13:50:40 -07003137 ViewGroup layout = mHotseat.getShortcutsAndWidgets();
Sunny Goyala1365452015-10-01 15:46:24 -07003138 for (int j = 0; j < layout.getChildCount(); j++) {
3139 Object tag = layout.getChildAt(j).getTag();
3140 if (tag != null) {
3141 writer.println(prefix + " " + tag.toString());
3142 }
Adam Cohen4caf2982013-08-20 18:54:31 -07003143 }
Sunny Goyala1365452015-10-01 15:46:24 -07003144 }
3145
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08003146 writer.println(prefix + "Misc:");
Winson Chungef528762019-09-06 12:05:52 -07003147 dumpMisc(prefix + "\t", writer);
3148 writer.println(prefix + "\tmWorkspaceLoading=" + mWorkspaceLoading);
3149 writer.println(prefix + "\tmPendingRequestArgs=" + mPendingRequestArgs
3150 + " mPendingActivityResult=" + mPendingActivityResult);
3151 writer.println(prefix + "\tmRotationHelper: " + mRotationHelper);
Sihua Ma0593a0d2022-10-03 16:01:48 -07003152 writer.println(prefix + "\tmAppWidgetHolder.isListening: "
3153 + mAppWidgetHolder.isListening());
Winson Chungef528762019-09-06 12:05:52 -07003154
Tony Wickham646e4482020-04-06 17:25:53 -07003155 // Extra logging for general debugging
Hyunyoung Songa310a802019-04-25 13:57:16 -07003156 mDragLayer.dump(prefix, writer);
3157 mStateManager.dump(prefix, writer);
Tony Wickham646e4482020-04-06 17:25:53 -07003158 mPopupDataProvider.dump(prefix, writer);
Pat Manning5f74bfd2022-07-20 12:08:54 +01003159 mDeviceProfile.dump(this, prefix, writer);
Sunny Goyal2bba1902018-02-27 12:20:50 -08003160
3161 try {
3162 FileLog.flushAll(writer);
3163 } catch (Exception e) {
3164 // Ignore
3165 }
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08003166
3167 mModel.dumpState(prefix, fd, writer, args);
Sunny Goyala1365452015-10-01 15:46:24 -07003168
Adam Cohen9211d422014-10-07 18:14:53 -07003169 if (mLauncherCallbacks != null) {
3170 mLauncherCallbacks.dump(prefix, fd, writer, args);
3171 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -07003172 mOverlayManager.dump(prefix, writer);
Adam Cohen16d7ffc2011-10-05 17:49:14 -07003173 }
Adam Cohen487f7dd2012-06-28 18:12:10 -07003174
Sunny Goyal66b24572016-09-21 15:57:55 -07003175 @Override
Sunny Goyal66b24572016-09-21 15:57:55 -07003176 public void onProvideKeyboardShortcuts(
3177 List<KeyboardShortcutGroup> data, Menu menu, int deviceId) {
3178
3179 ArrayList<KeyboardShortcutInfo> shortcutInfos = new ArrayList<>();
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07003180 if (isInState(NORMAL)) {
Sunny Goyal66b24572016-09-21 15:57:55 -07003181 shortcutInfos.add(new KeyboardShortcutInfo(getString(R.string.all_apps_button_label),
3182 KeyEvent.KEYCODE_A, KeyEvent.META_CTRL_ON));
Vadim Tryshev74c261c2018-06-12 13:44:43 -07003183 shortcutInfos.add(new KeyboardShortcutInfo(getString(R.string.widget_button_text),
3184 KeyEvent.KEYCODE_W, KeyEvent.META_CTRL_ON));
Sunny Goyal66b24572016-09-21 15:57:55 -07003185 }
Sunny Goyal384b5782021-02-09 22:50:02 -08003186 getSupportedActions(this, getCurrentFocus()).forEach(la ->
Vadim Tryshev3455f8d2018-05-11 20:02:20 -07003187 shortcutInfos.add(new KeyboardShortcutInfo(
Sunny Goyal384b5782021-02-09 22:50:02 -08003188 la.accessibilityAction.getLabel(), la.keyCode, KeyEvent.META_CTRL_ON)));
Sunny Goyal66b24572016-09-21 15:57:55 -07003189 if (!shortcutInfos.isEmpty()) {
3190 data.add(new KeyboardShortcutGroup(getString(R.string.home_screen), shortcutInfos));
3191 }
3192
3193 super.onProvideKeyboardShortcuts(data, menu, deviceId);
3194 }
3195
3196 @Override
3197 public boolean onKeyShortcut(int keyCode, KeyEvent event) {
3198 if (event.hasModifiers(KeyEvent.META_CTRL_ON)) {
3199 switch (keyCode) {
3200 case KeyEvent.KEYCODE_A:
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07003201 if (isInState(NORMAL)) {
3202 getStateManager().goToState(ALL_APPS);
Sunny Goyal66b24572016-09-21 15:57:55 -07003203 return true;
3204 }
3205 break;
Vadim Tryshev74c261c2018-06-12 13:44:43 -07003206 case KeyEvent.KEYCODE_W:
3207 if (isInState(NORMAL)) {
3208 OptionsPopupView.openWidgets(this);
3209 return true;
3210 }
3211 break;
Sunny Goyal384b5782021-02-09 22:50:02 -08003212 default:
3213 for (LauncherAction la : getSupportedActions(this, getCurrentFocus())) {
3214 if (la.keyCode == keyCode) {
3215 return la.invokeFromKeyboard(getCurrentFocus());
3216 }
3217 }
Sunny Goyal66b24572016-09-21 15:57:55 -07003218 }
3219 }
3220 return super.onKeyShortcut(keyCode, event);
3221 }
3222
Vadim Tryshev646a0dd2018-02-05 16:27:50 -08003223 @Override
Josep del Rio1d976c62023-05-04 16:07:50 +00003224 public boolean onKeyDown(int keyCode, KeyEvent event) {
3225 if (keyCode == KeyEvent.KEYCODE_ESCAPE) {
3226 // Close any open floating views.
3227 closeOpenViews();
3228 return true;
3229 }
3230 return super.onKeyDown(keyCode, event);
3231 }
3232
3233 @Override
Vadim Tryshev646a0dd2018-02-05 16:27:50 -08003234 public boolean onKeyUp(int keyCode, KeyEvent event) {
3235 if (keyCode == KeyEvent.KEYCODE_MENU) {
3236 // KEYCODE_MENU is sent by some tests, for example
3237 // LauncherJankTests#testWidgetsContainerFling. Don't just remove its handling.
3238 if (!mDragController.isDragging() && !mWorkspace.isSwitchingState() &&
3239 isInState(NORMAL)) {
3240 // Close any open floating views.
Andy Wickham65ced1b2020-03-07 02:14:19 +00003241 closeOpenViews();
Vadim Tryshev646a0dd2018-02-05 16:27:50 -08003242
3243 // Setting the touch point to (-1, -1) will show the options popup in the center of
3244 // the screen.
Brian Isganitisfdd044e2023-03-02 19:45:23 +00003245 if (Utilities.isRunningInTestHarness()) {
vadimtbc5d7e62019-12-09 13:53:05 -08003246 Log.d(TestProtocol.PERMANENT_DIAG_TAG, "Opening options popup on key up");
3247 }
Sunny Goyal831212e2021-05-14 14:24:09 -07003248 showDefaultOptions(-1, -1);
Vadim Tryshev646a0dd2018-02-05 16:27:50 -08003249 }
3250 return true;
3251 }
3252 return super.onKeyUp(keyCode, event);
3253 }
3254
Sunny Goyal831212e2021-05-14 14:24:09 -07003255 /**
3256 * Shows the default options popup
3257 */
3258 public void showDefaultOptions(float x, float y) {
Brian Isganitisa85ae692021-09-23 19:56:24 -04003259 OptionsPopupView.show(this, getPopupTarget(x, y), OptionsPopupView.getOptions(this),
3260 false);
3261 }
3262
3263 /**
3264 * Returns target rectangle for anchoring a popup menu.
3265 */
3266 protected RectF getPopupTarget(float x, float y) {
Sunny Goyal831212e2021-05-14 14:24:09 -07003267 float halfSize = getResources().getDimension(R.dimen.options_menu_thumb_size) / 2;
3268 if (x < 0 || y < 0) {
3269 x = mDragLayer.getWidth() / 2;
3270 y = mDragLayer.getHeight() / 2;
3271 }
Brian Isganitisa85ae692021-09-23 19:56:24 -04003272 return new RectF(x - halfSize, y - halfSize, x + halfSize, y + halfSize);
3273 }
3274
3275 @Override
Charlie Anderson8ad91442023-01-09 13:55:59 -05003276 public boolean canUseMultipleShadesForPopup() {
Brian Isganitisa85ae692021-09-23 19:56:24 -04003277 return getTopOpenViewWithType(this, TYPE_FOLDER) == null
3278 && getStateManager().getState() != LauncherState.ALL_APPS;
Sunny Goyal831212e2021-05-14 14:24:09 -07003279 }
3280
Sunny Goyalb5181c82021-03-10 07:39:12 +00003281 @Override
3282 protected void collectStateHandlers(List<StateHandler> out) {
3283 out.add(getAllAppsController());
3284 out.add(getWorkspace());
Andrew Sappersteinabef55a2016-06-19 12:49:00 -07003285 }
3286
Sunny Goyal210e1742019-10-17 12:05:38 -07003287 public TouchController[] createTouchControllers() {
3288 return new TouchController[] {getDragController(), new AllAppsSwipeController(this)};
3289 }
3290
Sunny Goyal1eb11242022-09-09 17:14:45 -07003291 public void onDragLayerHierarchyChanged() {
3292 updateDisallowBack();
3293 }
3294
Vinit Nayak65460402023-08-11 15:40:07 -07003295 protected void addBackAnimationCallback(BackPressHandler callback) {
3296 mBackPressedHandlers.add(callback);
3297 }
3298
3299 protected void removeBackAnimationCallback(BackPressHandler callback) {
3300 mBackPressedHandlers.remove(callback);
3301 }
3302
Sunny Goyal1eb11242022-09-09 17:14:45 -07003303 private void updateDisallowBack() {
Sukesh Ram3f2338a2023-08-28 18:31:54 +00003304 if (DESKTOP_MODE_SUPPORTED) {
Ats Jenk8121e0d2022-12-01 11:34:43 -08003305 // Do not disable back in launcher when prototype behavior is enabled
3306 return;
3307 }
Sunny Goyal1eb11242022-09-09 17:14:45 -07003308 LauncherRootView rv = getRootView();
3309 if (rv != null) {
Vinit Nayak65460402023-08-11 15:40:07 -07003310 boolean isSplitSelectionEnabled = isSplitSelectionEnabled();
Sunny Goyal1eb11242022-09-09 17:14:45 -07003311 boolean disableBack = getStateManager().getState() == NORMAL
Vinit Nayak65460402023-08-11 15:40:07 -07003312 && AbstractFloatingView.getTopOpenView(this) == null
3313 && !isSplitSelectionEnabled;
Sunny Goyal1eb11242022-09-09 17:14:45 -07003314 rv.setDisallowBackGesture(disableBack);
3315 }
3316 }
Sunny Goyal210e1742019-10-17 12:05:38 -07003317
Vinit Nayak65460402023-08-11 15:40:07 -07003318 /** To be overridden by subclasses */
3319 protected boolean isSplitSelectionEnabled() {
3320 // Overridden
3321 return false;
3322 }
3323
Vinit Nayakf9b585b2019-07-10 14:25:32 -07003324 @Override
3325 public void returnToHomescreen() {
3326 super.returnToHomescreen();
3327 getStateManager().goToState(LauncherState.NORMAL);
3328 }
3329
Andy Wickham65ced1b2020-03-07 02:14:19 +00003330 private void closeOpenViews() {
3331 closeOpenViews(true);
3332 }
3333
3334 protected void closeOpenViews(boolean animate) {
3335 AbstractFloatingView.closeAllOpenViews(this, animate);
3336 }
3337
Sunny Goyal3a1eadd2019-10-23 17:44:27 -07003338 public Stream<SystemShortcut.Factory> getSupportedShortcuts() {
Samuel Fufa5cf3e862020-02-03 20:22:54 -08003339 return Stream.of(APP_INFO, WIDGETS, INSTALL);
Sunny Goyal3a1eadd2019-10-23 17:44:27 -07003340 }
3341
Sunny Goyal384b5782021-02-09 22:50:02 -08003342 protected LauncherAccessibilityDelegate createAccessibilityDelegate() {
3343 return new LauncherAccessibilityDelegate(this);
3344 }
Sunny Goyalf2393f12020-04-01 20:13:12 -07003345
Schneider Victor-tulias7cd0ae32023-03-21 11:46:18 -07003346 /** Enables/disabled the hotseat prediction icon long press edu for testing. */
3347 @VisibleForTesting
3348 public void enableHotseatEdu(boolean enable) {}
3349
Sunny Goyalf2393f12020-04-01 20:13:12 -07003350 /**
3351 * @see LauncherState#getOverviewScaleAndOffset(Launcher)
3352 */
3353 public float[] getNormalOverviewScaleAndOffset() {
Tony Wickham82d5a062021-05-14 14:37:12 -07003354 return new float[] {NO_SCALE, NO_OFFSET};
Sunny Goyalf2393f12020-04-01 20:13:12 -07003355 }
3356
Sunny Goyal210e1742019-10-17 12:05:38 -07003357 public static Launcher getLauncher(Context context) {
Winson Chung8687bc22020-02-27 23:34:24 -08003358 return fromContext(context);
Sunny Goyal210e1742019-10-17 12:05:38 -07003359 }
3360
Sunny Goyal3dce5f32017-10-05 11:40:05 -07003361 /**
Sunny Goyalab770a12018-11-14 15:17:26 -08003362 * Just a wrapper around the type cast to allow easier tracking of calls.
3363 */
3364 public static <T extends Launcher> T cast(ActivityContext activityContext) {
3365 return (T) activityContext;
3366 }
3367
Sunny Goyalb65d7662021-03-07 15:09:11 -08003368 public boolean supportsAdaptiveIconAnimation(View clickedView) {
3369 return false;
3370 }
3371
Schneider Victor-tulias9b6babf2022-03-24 14:47:32 -07003372 /**
3373 * Animates Launcher elements during a transition to the All Apps page.
3374 *
3375 * @param progress Transition progress from 0 to 1; where 0 => home and 1 => all apps.
3376 */
3377 public void onAllAppsTransition(float progress) {
3378 // No-Op
3379 }
3380
3381 /**
3382 * Animates Launcher elements during a transition to the Widgets pages.
3383 *
3384 * @param progress Transition progress from 0 to 1; where 0 => home and 1 => widgets.
3385 */
3386 public void onWidgetsTransition(float progress) {
Alex Chau3d2c0622022-09-01 21:28:14 +01003387 float scale = Utilities.mapToRange(progress, 0f, 1f, 1f,
3388 mDeviceProfile.bottomSheetWorkspaceScale, EMPHASIZED);
3389 WORKSPACE_WIDGET_SCALE.set(getWorkspace(), scale);
3390 HOTSEAT_WIDGET_SCALE.set(getHotseat(), scale);
Schneider Victor-tulias9b6babf2022-03-24 14:47:32 -07003391 }
3392
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08003393 private static class NonConfigInstance {
3394 public Configuration config;
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08003395 }
thiruramc96873c2021-02-11 15:13:47 -08003396
3397 @Override
3398 public StatsLogManager getStatsLogManager() {
3399 return super.getStatsLogManager().withDefaultInstanceId(mAllAppsSessionLogId);
3400 }
Brian Isganitis149dbcb2021-11-08 18:12:38 -05003401
3402 /**
3403 * Returns the current popup for testing, if any.
3404 */
3405 @VisibleForTesting
3406 @Nullable
3407 public ArrowPopup<?> getOptionsPopup() {
3408 return findViewById(R.id.popup_container);
3409 }
Schneider Victor-tulias789a6a92022-03-04 12:06:09 -08003410
3411 /** Pauses view updates that should not be run during the app launch animation. */
3412 public void pauseExpensiveViewUpdates() {
3413 // Pause page indicator animations as they lead to layer trashing.
Shikha Malhotrae957b602022-04-11 07:57:18 +00003414 getWorkspace().getPageIndicator().pauseAnimations();
Jon Miranda46ecc0c2022-06-02 11:34:15 -07003415
3416 getWorkspace().mapOverItems((info, view) -> {
3417 if (view instanceof LauncherAppWidgetHostView) {
3418 ((LauncherAppWidgetHostView) view).beginDeferringUpdates();
3419 }
3420 return false; // Return false to continue iterating through all the items.
3421 });
Schneider Victor-tulias789a6a92022-03-04 12:06:09 -08003422 }
3423
3424 /** Resumes view updates at the end of the app launch animation. */
3425 public void resumeExpensiveViewUpdates() {
Shikha Malhotrae957b602022-04-11 07:57:18 +00003426 getWorkspace().getPageIndicator().skipAnimationsToEnd();
Shikha Malhotra0f2e1b62022-03-27 21:02:21 +00003427
Jon Miranda46ecc0c2022-06-02 11:34:15 -07003428 getWorkspace().mapOverItems((info, view) -> {
3429 if (view instanceof LauncherAppWidgetHostView) {
3430 ((LauncherAppWidgetHostView) view).endDeferringUpdates();
3431 }
3432 return false; // Return false to continue iterating through all the items.
3433 });
3434 }
Ats Jenkca009e42023-01-06 09:52:40 -08003435
3436 /**
3437 * Returns {@code true} if there are visible tasks with windowing mode set to
3438 * {@link android.app.WindowConfiguration#WINDOWING_MODE_FREEFORM}
3439 */
3440 public boolean areFreeformTasksVisible() {
3441 return false; // Base launcher does not track freeform tasks
3442 }
Brian Isganitisf54c6fa2023-07-11 12:47:08 -04003443
3444 @Override
3445 public View.OnLongClickListener getAllAppsItemLongClickListener() {
3446 return ItemLongClickListener.INSTANCE_ALL_APPS;
3447 }
Jeremy Sim94fd07e2023-04-19 20:56:49 -07003448
3449 /**
3450 * Handles an app pair launch; overridden in
3451 * {@link com.android.launcher3.uioverrides.QuickstepLauncher}
3452 */
3453 public void launchAppPair(WorkspaceItemInfo app1, WorkspaceItemInfo app2) {
3454 // Overridden
3455 }
Sunny Goyal0ee66472023-08-17 16:19:22 -07003456
3457 /**
3458 * Returns the animation coordinator for playing one-off animations
3459 */
3460 public CannedAnimationCoordinator getAnimationCoordinator() {
3461 return mAnimationCoordinator;
3462 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003463}