blob: fcd147ffdf0113f959f5a5a7209dacae5c7a6a8f [file] [log] [blame]
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Daniel Sandler325dc232013-06-05 22:57:57 -040017package com.android.launcher3;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080018
Sunny Goyalf8d56fc2018-01-31 15:18:11 -080019import static android.content.pm.ActivityInfo.CONFIG_ORIENTATION;
20import static android.content.pm.ActivityInfo.CONFIG_SCREEN_SIZE;
Sunny Goyal6c0c61a2020-12-08 19:19:56 -080021import static android.content.pm.ActivityInfo.CONFIG_UI_MODE;
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -070022import static android.view.View.IMPORTANT_FOR_ACCESSIBILITY_NO;
Sunny Goyal8f965462020-04-23 19:00:36 -070023import static android.view.accessibility.AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED;
Vinit Nayak48b28022020-04-27 20:48:49 +000024
Pinyao Tinga74b63a2019-07-17 23:26:06 -070025import static com.android.launcher3.AbstractFloatingView.TYPE_ALL;
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;
Sunny Goyal4c7f2152017-10-17 17:17:16 -070031import static com.android.launcher3.LauncherAnimUtils.SPRING_LOADED_EXIT_DELAY;
Jon Mirandac4a99bf2021-11-04 16:53:45 -070032import static com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_APPLICATION;
Sunny Goyal3e3f44c2017-10-23 17:14:52 -070033import static com.android.launcher3.LauncherState.ALL_APPS;
Sunny Goyal8f965462020-04-23 19:00:36 -070034import static com.android.launcher3.LauncherState.FLAG_CLOSE_POPUPS;
35import static com.android.launcher3.LauncherState.FLAG_MULTI_PAGE;
36import static com.android.launcher3.LauncherState.FLAG_NON_INTERACTIVE;
Sunny Goyal3e3f44c2017-10-23 17:14:52 -070037import static com.android.launcher3.LauncherState.NORMAL;
Sunny Goyalf2393f12020-04-01 20:13:12 -070038import static com.android.launcher3.LauncherState.NO_OFFSET;
39import static com.android.launcher3.LauncherState.NO_SCALE;
Sunny Goyal8f965462020-04-23 19:00:36 -070040import static com.android.launcher3.LauncherState.SPRING_LOADED;
Sunny Goyalb1d7de22019-09-06 10:36:54 -070041import static com.android.launcher3.Utilities.postAsyncCallback;
Sunny Goyal384b5782021-02-09 22:50:02 -080042import static com.android.launcher3.accessibility.LauncherAccessibilityDelegate.getSupportedActions;
Sunny Goyal6001ea22018-05-10 16:31:00 -070043import static com.android.launcher3.dragndrop.DragLayer.ALPHA_INDEX_LAUNCHER_LOAD;
Thiru Ramasamy5fbac632022-01-28 15:05:36 -080044import static com.android.launcher3.logging.StatsLogManager.EventEnum;
Hyunyoung Song801f81f2020-06-19 02:58:53 -070045import static com.android.launcher3.logging.StatsLogManager.LAUNCHER_STATE_BACKGROUND;
Hyunyoung Song95786e02020-09-15 00:34:10 -070046import static com.android.launcher3.logging.StatsLogManager.LAUNCHER_STATE_HOME;
thiruramc96873c2021-02-11 15:13:47 -080047import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ALLAPPS_ENTRY;
thiruram9f53d612021-02-24 10:54:01 -080048import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ALLAPPS_ENTRY_WITH_DEVICE_SEARCH;
thiruramc96873c2021-02-11 15:13:47 -080049import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ALLAPPS_EXIT;
Hyunyoung Song801f81f2020-06-19 02:58:53 -070050import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ONRESUME;
51import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ONSTOP;
Yogisha Dixit4ff5ee32021-05-04 14:58:34 +010052import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_WIDGET_RECONFIGURED;
Sunny Goyal60e68c92020-08-12 13:59:27 -070053import static com.android.launcher3.model.ItemInstallQueue.FLAG_ACTIVITY_PAUSED;
54import static com.android.launcher3.model.ItemInstallQueue.FLAG_DRAG_AND_DROP;
Sunny Goyal3a1eadd2019-10-23 17:44:27 -070055import static com.android.launcher3.popup.SystemShortcut.APP_INFO;
Sunny Goyal3a1eadd2019-10-23 17:44:27 -070056import static com.android.launcher3.popup.SystemShortcut.INSTALL;
57import static com.android.launcher3.popup.SystemShortcut.WIDGETS;
Sunny Goyal8f965462020-04-23 19:00:36 -070058import static com.android.launcher3.states.RotationHelper.REQUEST_LOCK;
Sunny Goyalbe8c3402019-05-22 15:17:52 -070059import static com.android.launcher3.states.RotationHelper.REQUEST_NONE;
Jon Mirandac4a99bf2021-11-04 16:53:45 -070060import static com.android.launcher3.util.ItemInfoMatcher.forFolderMatch;
Sunny Goyal326403e2017-10-02 12:45:10 -070061
Gilles Debunnedd6c9922010-10-25 11:23:41 -070062import android.animation.Animator;
Sunny Goyal6001ea22018-05-10 16:31:00 -070063import android.animation.AnimatorListenerAdapter;
Gilles Debunnedd6c9922010-10-25 11:23:41 -070064import android.animation.AnimatorSet;
Sunny Goyal6001ea22018-05-10 16:31:00 -070065import android.animation.ObjectAnimator;
Gilles Debunnedd6c9922010-10-25 11:23:41 -070066import android.animation.ValueAnimator;
Adam Cohen0b395352014-06-09 22:54:36 +000067import android.annotation.TargetApi;
Tony Wickhame78a70b2021-03-29 16:45:59 -070068import android.app.Notification;
69import android.app.NotificationChannel;
70import android.app.NotificationManager;
71import android.app.PendingIntent;
Adam Cohen0cf2a7c2011-11-08 15:07:01 -080072import android.appwidget.AppWidgetHostView;
Michael Jurkaaf442092010-06-10 17:01:57 -070073import android.appwidget.AppWidgetManager;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080074import android.content.ActivityNotFoundException;
Joe Onorato2ca0ae72009-11-10 13:14:13 -080075import android.content.BroadcastReceiver;
Michael Jurkae326f182011-11-21 14:05:46 -080076import android.content.ComponentCallbacks2;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080077import android.content.Context;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080078import android.content.Intent;
Winson Chungf0ea4d32011-06-06 14:27:16 -070079import android.content.IntentFilter;
Adam Cohen173f7112015-03-27 15:14:00 -070080import android.content.IntentSender;
Winson Chung82f55532011-08-09 14:14:23 -070081import android.content.SharedPreferences;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080082import android.content.pm.PackageManager;
Sunny Goyalf8d56fc2018-01-31 15:18:11 -080083import android.content.res.Configuration;
Adam Cohen3f9c9712014-10-31 11:48:25 -070084import android.database.sqlite.SQLiteDatabase;
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -070085import android.graphics.Bitmap;
Tony Wickham1906cc32021-02-11 11:55:24 -080086import android.graphics.Rect;
Sunny Goyal831212e2021-05-14 14:24:09 -070087import android.graphics.RectF;
Adam Cohen0f668f32014-09-08 19:54:17 +020088import android.os.Build;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080089import android.os.Bundle;
Sunny Goyal210e1742019-10-17 12:05:38 -070090import android.os.CancellationSignal;
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -070091import android.os.Parcelable;
Sunny Goyal7c74e4a2016-12-15 15:53:17 -080092import android.os.Process;
Winson Chunga2413752012-04-03 14:22:34 -070093import android.os.StrictMode;
Riddle Hsu979da642020-09-22 21:52:40 +080094import android.os.SystemClock;
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -070095import android.os.Trace;
Jon Mirandac4a99bf2021-11-04 16:53:45 -070096import android.os.UserHandle;
Michael Jurkaa33411c2012-06-14 16:18:21 -070097import android.text.TextUtils;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080098import android.text.method.TextKeyListener;
Joe Onorato7c312c12009-08-13 21:36:53 -070099import android.util.Log;
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -0700100import android.util.SparseArray;
Adam Cohen96d30a12013-07-16 18:13:21 -0700101import android.view.KeyEvent;
Sunny Goyal66b24572016-09-21 15:57:55 -0700102import android.view.KeyboardShortcutGroup;
103import android.view.KeyboardShortcutInfo;
Sunny Goyal9b29ca52017-02-17 10:39:44 -0800104import android.view.LayoutInflater;
Adam Cohen96d30a12013-07-16 18:13:21 -0700105import android.view.Menu;
vadimt9af34a72020-01-21 11:19:13 -0800106import android.view.MotionEvent;
Adam Cohen96d30a12013-07-16 18:13:21 -0700107import android.view.View;
Adam Cohen96d30a12013-07-16 18:13:21 -0700108import android.view.ViewGroup;
Pinyao Ting85232a92021-12-14 04:36:01 +0000109import android.view.ViewTreeObserver;
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -0700110import android.view.WindowManager.LayoutParams;
Svetoslav Ganov815ba2d2011-01-07 14:55:17 -0800111import android.view.accessibility.AccessibilityEvent;
Sunny Goyal5a1f53b2015-05-27 10:24:24 -0700112import android.view.animation.OvershootInterpolator;
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -0700113import android.widget.ImageView;
Adam Cohen96d30a12013-07-16 18:13:21 -0700114import android.widget.Toast;
Sunny Goyala1d1bf32015-06-26 13:24:53 -0700115
Sunny Goyal35e7d382020-05-08 13:37:58 -0700116import androidx.annotation.CallSuper;
Andras Kloczl55edfe52021-05-14 12:21:30 +0200117import androidx.annotation.NonNull;
Sunny Goyal11a50742019-08-07 09:24:26 -0700118import androidx.annotation.Nullable;
Pinyao Tingc9074272019-11-11 11:51:44 -0800119import androidx.annotation.StringRes;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700120import androidx.annotation.VisibleForTesting;
Sunny Goyal11a50742019-08-07 09:24:26 -0700121
Sunny Goyal651077b2014-06-30 14:15:31 -0700122import com.android.launcher3.DropTarget.DragObject;
Schneider Victor-tuliasbdb0dd82021-11-03 16:26:41 -0700123import com.android.launcher3.accessibility.BaseAccessibilityDelegate.LauncherAction;
Sunny Goyalae502842016-06-17 08:43:56 -0700124import com.android.launcher3.accessibility.LauncherAccessibilityDelegate;
Brian Isganitis1664c9f2022-01-14 23:15:47 -0500125import com.android.launcher3.allapps.ActivityAllAppsContainerView;
vadimtd4c90e12019-06-04 13:59:43 -0700126import com.android.launcher3.allapps.AllAppsStore;
Hyunyoung Song645764e2016-06-06 14:19:02 -0700127import com.android.launcher3.allapps.AllAppsTransitionController;
kholoud mohamedceec31b2022-02-03 15:44:25 +0000128import com.android.launcher3.allapps.BaseAllAppsContainerView;
Sunny Goyal7ede6112017-12-05 15:11:21 -0800129import com.android.launcher3.allapps.DiscoveryBounce;
Sunny Goyal4a48a982021-06-17 15:15:46 -0700130import com.android.launcher3.anim.AnimatorListeners;
Sunny Goyalf0b6db72018-08-13 16:10:14 -0700131import com.android.launcher3.anim.PropertyListBuilder;
Sunny Goyal8f965462020-04-23 19:00:36 -0700132import com.android.launcher3.compat.AccessibilityManagerCompat;
Tony Wickhame0c33232016-02-08 11:37:04 -0800133import com.android.launcher3.config.FeatureFlags;
vadimt00d42552018-12-11 17:59:36 -0800134import com.android.launcher3.dot.DotInfo;
Vadim Tryshevfedca432015-08-19 17:55:02 -0700135import com.android.launcher3.dragndrop.DragController;
136import com.android.launcher3.dragndrop.DragLayer;
Tony Wickham39938cb2021-02-26 09:15:31 -0800137import com.android.launcher3.dragndrop.DragOptions;
Vadim Tryshevfedca432015-08-19 17:55:02 -0700138import com.android.launcher3.dragndrop.DragView;
Sunny Goyal59969372021-05-06 12:11:44 -0700139import com.android.launcher3.dragndrop.LauncherDragController;
Sunny Goyal11a50742019-08-07 09:24:26 -0700140import com.android.launcher3.folder.FolderGridOrganizer;
Sunny Goyal26119432016-02-18 22:09:23 +0000141import com.android.launcher3.folder.FolderIcon;
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -0700142import com.android.launcher3.icons.BitmapRenderer;
Sunny Goyalf840f102018-09-21 14:41:05 -0700143import com.android.launcher3.icons.IconCache;
Sunny Goyal3333b0c2016-05-09 20:43:21 -0700144import com.android.launcher3.keyboard.ViewGroupFocusHelper;
Hyunyoung Song801f81f2020-06-19 02:58:53 -0700145import com.android.launcher3.logger.LauncherAtom;
Thiru Ramasamy5fbac632022-01-28 15:05:36 -0800146import com.android.launcher3.logger.LauncherAtom.ContainerInfo;
147import com.android.launcher3.logger.LauncherAtom.WorkspaceContainer;
Sunny Goyala7ce1662016-05-31 15:01:35 -0700148import com.android.launcher3.logging.FileLog;
thiruramc96873c2021-02-11 15:13:47 -0800149import com.android.launcher3.logging.InstanceId;
150import com.android.launcher3.logging.InstanceIdSequence;
Hyunyoung Song801f81f2020-06-19 02:58:53 -0700151import com.android.launcher3.logging.StatsLogManager;
Sunny Goyal87dcde62019-07-17 20:35:56 -0700152import com.android.launcher3.model.BgDataModel.Callbacks;
Sunny Goyal60e68c92020-08-12 13:59:27 -0700153import com.android.launcher3.model.ItemInstallQueue;
Sunny Goyal53116c62020-08-07 16:32:18 -0700154import com.android.launcher3.model.ModelUtils;
Sunny Goyala535ae42017-02-27 10:07:13 -0800155import com.android.launcher3.model.ModelWriter;
kholoud mohamedc76b2032021-12-20 16:47:38 +0000156import com.android.launcher3.model.StringCache;
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -0700157import com.android.launcher3.model.WidgetsModel;
Sunny Goyale396abf2020-04-06 15:11:17 -0700158import com.android.launcher3.model.data.AppInfo;
159import com.android.launcher3.model.data.FolderInfo;
160import com.android.launcher3.model.data.ItemInfo;
161import com.android.launcher3.model.data.LauncherAppWidgetInfo;
Sunny Goyale396abf2020-04-06 15:11:17 -0700162import com.android.launcher3.model.data.WorkspaceItemInfo;
Sunny Goyala535ae42017-02-27 10:07:13 -0800163import com.android.launcher3.notification.NotificationListener;
Sunny Goyale7b00122019-10-02 16:13:34 -0700164import com.android.launcher3.pm.PinRequestHelper;
Samuel Fufa41d909f2020-03-20 16:27:09 -0700165import com.android.launcher3.pm.UserCache;
Brian Isganitis149dbcb2021-11-08 18:12:38 -0500166import com.android.launcher3.popup.ArrowPopup;
Tony Wickham540913e2017-01-23 11:47:51 -0800167import com.android.launcher3.popup.PopupContainerWithArrow;
Sunny Goyala535ae42017-02-27 10:07:13 -0800168import com.android.launcher3.popup.PopupDataProvider;
Sunny Goyal3a1eadd2019-10-23 17:44:27 -0700169import com.android.launcher3.popup.SystemShortcut;
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700170import com.android.launcher3.qsb.QsbContainerView;
Sunny Goyal35e7d382020-05-08 13:37:58 -0700171import com.android.launcher3.statemanager.StateManager;
172import com.android.launcher3.statemanager.StateManager.StateHandler;
Sunny Goyal35e7d382020-05-08 13:37:58 -0700173import com.android.launcher3.statemanager.StatefulActivity;
Sunny Goyal623eddd2018-03-02 12:24:41 -0800174import com.android.launcher3.states.RotationHelper;
vadimt9af34a72020-01-21 11:19:13 -0800175import com.android.launcher3.testing.TestLogging;
vadimtbc5d7e62019-12-09 13:53:05 -0800176import com.android.launcher3.testing.TestProtocol;
Sunny Goyal210e1742019-10-17 12:05:38 -0700177import com.android.launcher3.touch.AllAppsSwipeController;
Sunny Goyal8a2a63b2018-03-06 22:15:18 -0800178import com.android.launcher3.touch.ItemClickHandler;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700179import com.android.launcher3.uioverrides.plugins.PluginManagerWrapper;
Sunny Goyal2100c782016-08-22 16:00:03 -0700180import com.android.launcher3.util.ActivityResultInfo;
Sunny Goyale84c5b82019-09-26 17:05:31 -0700181import com.android.launcher3.util.ActivityTracker;
Winson Chung6b1c73f2015-06-18 11:38:42 -0700182import com.android.launcher3.util.ComponentKey;
Sunny Goyalefb7e842018-10-04 15:11:00 -0700183import com.android.launcher3.util.IntArray;
Andras Kloczl55edfe52021-05-14 12:21:30 +0200184import com.android.launcher3.util.IntSet;
Sunny Goyald3b87ef2016-07-28 12:11:54 -0700185import com.android.launcher3.util.ItemInfoMatcher;
Sunny Goyal6001ea22018-05-10 16:31:00 -0700186import com.android.launcher3.util.MultiValueAlpha;
187import com.android.launcher3.util.MultiValueAlpha.AlphaProperty;
Tony Wickham133cd542020-04-08 17:48:41 -0700188import com.android.launcher3.util.OnboardingPrefs;
Sunny Goyal04cc3a72016-05-17 10:32:43 -0700189import com.android.launcher3.util.PackageManagerHelper;
Tony Wickham010d2552017-01-20 08:15:28 -0800190import com.android.launcher3.util.PackageUserKey;
Sunny Goyal2100c782016-08-22 16:00:03 -0700191import com.android.launcher3.util.PendingRequestArgs;
Sunny Goyal4a48a982021-06-17 15:15:46 -0700192import com.android.launcher3.util.RunnableList;
Samuel Fufa41d909f2020-03-20 16:27:09 -0700193import com.android.launcher3.util.SafeCloseable;
Sunny Goyal8392c822017-06-20 10:03:56 -0700194import com.android.launcher3.util.SystemUiController;
Mario Bertschlera6936942017-05-31 14:48:19 -0700195import com.android.launcher3.util.Themes;
Adam Cohen091440a2015-03-18 14:16:05 -0700196import com.android.launcher3.util.Thunk;
Sunny Goyal210e1742019-10-17 12:05:38 -0700197import com.android.launcher3.util.TouchController;
Sunny Goyalfca6bc92017-09-28 16:28:34 -0700198import com.android.launcher3.util.TraceHelper;
Sunny Goyal326403e2017-10-02 12:45:10 -0700199import com.android.launcher3.util.UiThreadHelper;
Sunny Goyal527c7d32015-08-28 15:19:36 -0700200import com.android.launcher3.util.ViewOnDrawExecutor;
Sunny Goyalab770a12018-11-14 15:17:26 -0800201import com.android.launcher3.views.ActivityContext;
Sunny Goyal30ac97d2020-06-24 23:47:46 -0700202import com.android.launcher3.views.FloatingSurfaceView;
Sunny Goyal7c7be8c2018-03-07 19:58:07 -0800203import com.android.launcher3.views.OptionsPopupView;
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400204import com.android.launcher3.views.ScrimView;
Yogisha Dixit741fae92021-02-22 14:03:44 +0000205import com.android.launcher3.widget.LauncherAppWidgetHost;
Sunny Goyal29947f02017-12-18 13:49:44 -0800206import com.android.launcher3.widget.LauncherAppWidgetHostView;
Yogisha Dixit741fae92021-02-22 14:03:44 +0000207import com.android.launcher3.widget.LauncherAppWidgetProviderInfo;
Sunny Goyal782f0c92017-01-19 10:27:54 -0800208import com.android.launcher3.widget.PendingAddShortcutInfo;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700209import com.android.launcher3.widget.PendingAddWidgetInfo;
Sunny Goyal29947f02017-12-18 13:49:44 -0800210import com.android.launcher3.widget.PendingAppWidgetHostView;
Sunny Goyal04a324a2017-01-20 21:08:59 -0800211import com.android.launcher3.widget.WidgetAddFlowHandler;
Sunny Goyal337c81f2019-12-10 12:19:13 -0800212import com.android.launcher3.widget.WidgetManagerHelper;
Pinyao Tingc7a6c292019-08-26 14:36:02 -0700213import com.android.launcher3.widget.custom.CustomWidgetManager;
Steven Ng2f5648a2021-02-08 17:18:25 +0000214import com.android.launcher3.widget.model.WidgetsListBaseEntry;
215import com.android.launcher3.widget.picker.WidgetsFullSheet;
Sunny Goyal80a071b2021-12-27 13:30:08 +0530216import com.android.systemui.plugins.LauncherOverlayPlugin;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700217import com.android.systemui.plugins.PluginListener;
218import com.android.systemui.plugins.shared.LauncherExterns;
219import com.android.systemui.plugins.shared.LauncherOverlayManager;
220import com.android.systemui.plugins.shared.LauncherOverlayManager.LauncherOverlay;
221import com.android.systemui.plugins.shared.LauncherOverlayManager.LauncherOverlayCallbacks;
Adam Cohen6c5891a2014-07-09 23:53:15 -0700222
Adam Cohen16d7ffc2011-10-05 17:49:14 -0700223import java.io.FileDescriptor;
Adam Cohen16d7ffc2011-10-05 17:49:14 -0700224import java.io.PrintWriter;
Adam Cohenc0dcf592011-06-01 15:30:43 -0700225import java.util.ArrayList;
Winson Chungf0c6ae02012-03-21 16:10:31 -0700226import java.util.Collection;
Jon Mirandac4a99bf2021-11-04 16:53:45 -0700227import java.util.Collections;
Zak Cohen658c67a2018-10-19 14:21:05 -0700228import java.util.HashMap;
Sunny Goyal4390ace2014-10-13 11:33:11 -0700229import java.util.HashSet;
Michael Jurkad7c28052012-04-27 15:43:36 -0700230import java.util.List;
Sunny Goyalaae6fbb2019-01-31 16:05:58 -0800231import java.util.function.Predicate;
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700232import java.util.function.Supplier;
Sunny Goyal3a1eadd2019-10-23 17:44:27 -0700233import java.util.stream.Stream;
Jon Mirandaf5197fc2019-09-04 16:55:41 -0700234
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800235/**
236 * Default launcher application.
237 */
Sunny Goyal35e7d382020-05-08 13:37:58 -0700238public class Launcher extends StatefulActivity<LauncherState> implements LauncherExterns,
Sunny Goyal80a071b2021-12-27 13:30:08 +0530239 Callbacks, InvariantDeviceProfile.OnIDPChangeListener,
240 PluginListener<LauncherOverlayPlugin>, LauncherOverlayCallbacks {
Vadim Tryshevfedca432015-08-19 17:55:02 -0700241 public static final String TAG = "Launcher";
Sunny Goyale84c5b82019-09-26 17:05:31 -0700242
243 public static final ActivityTracker<Launcher> ACTIVITY_TRACKER = new ActivityTracker<>();
244
Sunny Goyal2bba4c32015-05-18 15:42:48 -0700245 static final boolean LOGD = false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800246
Winson Chunga2413752012-04-03 14:22:34 -0700247 static final boolean DEBUG_STRICT_MODE = false;
Romain Guy6fefcf12009-06-11 13:07:43 -0700248
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800249 private static final int REQUEST_CREATE_SHORTCUT = 1;
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700250 private static final int REQUEST_CREATE_APPWIDGET = 5;
Jon Mirandac476d6e2017-05-04 16:30:01 -0700251
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700252 private static final int REQUEST_PICK_APPWIDGET = 9;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800253
Michael Jurka8b805b12012-04-18 14:23:14 -0700254 private static final int REQUEST_BIND_APPWIDGET = 11;
Sunny Goyal8a2a63b2018-03-06 22:15:18 -0800255 public static final int REQUEST_BIND_PENDING_APPWIDGET = 12;
256 public static final int REQUEST_RECONFIGURE_APPWIDGET = 13;
Michael Jurka8b805b12012-04-18 14:23:14 -0700257
Jon Mirandac476d6e2017-05-04 16:30:01 -0700258 private static final int REQUEST_PERMISSION_CALL_PHONE = 14;
Sunny Goyal28c6b962015-10-12 11:42:05 -0700259
Sunny Goyal5a1f53b2015-05-27 10:24:24 -0700260 private static final float BOUNCE_ANIMATION_TENSION = 1.3f;
261
Mathew Inwood876a8462013-06-14 14:12:41 +0100262 /**
263 * IntentStarter uses request codes starting with this. This must be greater than all activity
264 * request codes used internally.
265 */
266 protected static final int REQUEST_LAST = 100;
267
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800268 // Type: int
Michael Jurka883f55b2010-10-21 15:47:14 -0700269 private static final String RUNTIME_STATE = "launcher.state";
Sunny Goyal2100c782016-08-22 16:00:03 -0700270 // Type: PendingRequestArgs
271 private static final String RUNTIME_STATE_PENDING_REQUEST_ARGS = "launcher.request_args";
Sunny Goyaldedda052019-05-14 15:23:48 -0700272 // Type: int
273 private static final String RUNTIME_STATE_PENDING_REQUEST_CODE = "launcher.request_code";
Sunny Goyal2100c782016-08-22 16:00:03 -0700274 // Type: ActivityResultInfo
275 private static final String RUNTIME_STATE_PENDING_ACTIVITY_RESULT = "launcher.activity_result";
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -0700276 // Type: SparseArray<Parcelable>
277 private static final String RUNTIME_STATE_WIDGET_PANEL = "launcher.widget_panel";
Sunny Goyal12e3f1f2021-07-15 14:31:58 -0700278 // Type int[]
279 private static final String RUNTIME_STATE_CURRENT_SCREEN_IDS = "launcher.current_screen_ids";
Sunny Goyal17c72fb2019-10-14 14:06:38 -0700280
vadimt00d42552018-12-11 17:59:36 -0800281 public static final String ON_CREATE_EVT = "Launcher.onCreate";
Sunny Goyal17c72fb2019-10-14 14:06:38 -0700282 public static final String ON_START_EVT = "Launcher.onStart";
283 public static final String ON_RESUME_EVT = "Launcher.onResume";
284 public static final String ON_NEW_INTENT_EVT = "Launcher.onNewIntent";
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800285
Sunny Goyal35e7d382020-05-08 13:37:58 -0700286 private StateManager<LauncherState> mStateManager;
Patrick Dubroy6b509c12010-08-23 15:08:16 -0700287
Adam Cohenad4e15c2013-10-17 16:21:35 -0700288 private static final int ON_ACTIVITY_RESULT_ANIMATION_DELAY = 500;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800289
Winson Chunga2413752012-04-03 14:22:34 -0700290 // How long to wait before the new-shortcut animation automatically pans the workspace
Jon Mirandaf5197fc2019-09-04 16:55:41 -0700291 @VisibleForTesting public static final int NEW_APPS_PAGE_MOVE_DELAY = 500;
Rajeev Kumar43c0f582017-06-23 15:34:55 -0700292 private static final int NEW_APPS_ANIMATION_INACTIVE_TIMEOUT_SECONDS = 5;
Jon Mirandaf5197fc2019-09-04 16:55:41 -0700293 @Thunk @VisibleForTesting public static final int NEW_APPS_ANIMATION_DELAY = 500;
Winson Chunga2413752012-04-03 14:22:34 -0700294
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -0700295 private static final int THEME_CROSS_FADE_ANIMATION_DURATION = 375;
296
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -0700297 private static final String DISPLAY_WORKSPACE_TRACE_METHOD_NAME = "DisplayWorkspaceFirstFrame";
298 private static final String DISPLAY_ALL_APPS_TRACE_METHOD_NAME = "DisplayAllApps";
299 public static final int DISPLAY_WORKSPACE_TRACE_COOKIE = 0;
300 public static final int DISPLAY_ALL_APPS_TRACE_COOKIE = 1;
301
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800302 private Configuration mOldConfig;
Jon Miranda54441f52018-01-24 15:38:25 -0800303
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700304 @Thunk
305 Workspace mWorkspace;
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700306 @Thunk
307 DragLayer mDragLayer;
Michael Jurkab737ee62011-11-15 15:57:22 -0800308 private DragController mDragController;
Sunny Goyal322d5562015-06-25 19:35:49 -0700309
Sunny Goyal337c81f2019-12-10 12:19:13 -0800310 private WidgetManagerHelper mAppWidgetManager;
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700311 private LauncherAppWidgetHost mAppWidgetHost;
Romain Guycbb89e42009-06-08 15:52:54 -0700312
Rajeev Kumar43c0f582017-06-23 15:34:55 -0700313 private final int[] mTmpAddItemCellCoordinates = new int[2];
Michael Jurka0280c3b2010-09-17 15:00:07 -0700314
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700315 @Thunk
316 Hotseat mHotseat;
Adam Cohenf358a4b2013-07-23 16:47:31 -0700317
Sunny Goyal47328fd2016-05-25 18:56:41 -0700318 private DropTargetBar mDropTargetBar;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700319
320 // Main container view for the all apps screen.
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700321 @Thunk
Brian Isganitis1664c9f2022-01-14 23:15:47 -0500322 ActivityAllAppsContainerView<Launcher> mAppsView;
Hyunyoung Song645764e2016-06-06 14:19:02 -0700323 AllAppsTransitionController mAllAppsController;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700324
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400325 // Scrim view for the all apps and overview state.
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700326 @Thunk
327 ScrimView mScrimView;
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400328
Winson Chung8ae41982017-11-10 11:42:13 -0800329 // UI and state for the overview panel
Sunny Goyal7c7be8c2018-03-07 19:58:07 -0800330 private View mOverviewPanel;
Winson Chung8ae41982017-11-10 11:42:13 -0800331
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700332 @Thunk
333 boolean mWorkspaceLoading = true;
Joe Onorato9c1289c2009-08-17 11:03:03 -0400334
Winson Chungc9bf6d42019-10-04 15:33:18 -0700335 // Used to notify when an activity launch has been deferred because launcher is not yet resumed
336 // TODO: See if we can remove this later
337 private Runnable mOnDeferredActivityLaunchCallback;
338
Sunny Goyal527c7d32015-08-28 15:19:36 -0700339 private ViewOnDrawExecutor mPendingExecutor;
Michael Jurka7607c2f2013-04-03 14:33:19 -0700340
Joe Onorato9c1289c2009-08-17 11:03:03 -0400341 private LauncherModel mModel;
Sunny Goyal43bf11d2017-02-02 13:52:53 -0800342 private ModelWriter mModelWriter;
Joe Onorato0589f0f2010-02-08 13:44:00 -0800343 private IconCache mIconCache;
Sunny Goyalae502842016-06-17 08:43:56 -0700344 private LauncherAccessibilityDelegate mAccessibilityDelegate;
Joe Onorato9c1289c2009-08-17 11:03:03 -0400345
Tony Wickham010d2552017-01-20 08:15:28 -0800346 private PopupDataProvider mPopupDataProvider;
Tony Wickhambfbf7f92016-05-19 11:19:39 -0700347
Andras Kloczl55edfe52021-05-14 12:21:30 +0200348 private IntSet mSynchronouslyBoundPages = new IntSet();
Sunny Goyal12e3f1f2021-07-15 14:31:58 -0700349 @NonNull private IntSet mPagesToBindSynchronously = new IntSet();
Adam Cohen1462de32012-07-24 22:34:36 -0700350
Winson Chung46353de2012-02-16 14:05:10 -0800351 // We only want to get the SharedPreferences once since it does an FS stat each time we get
352 // it from the context.
353 private SharedPreferences mSharedPrefs;
Brian Isganitis099945b2022-01-31 18:15:00 -0500354 private OnboardingPrefs<? extends Launcher> mOnboardingPrefs;
Winson Chung46353de2012-02-16 14:05:10 -0800355
Sunny Goyal2100c782016-08-22 16:00:03 -0700356 // Activity result which needs to be processed after workspace has loaded.
357 private ActivityResultInfo mPendingActivityResult;
358 /**
359 * Holds extra information required to handle a result from an external call, like
360 * {@link #startActivityForResult(Intent, int)} or {@link #requestPermissions(String[], int)}
361 */
362 private PendingRequestArgs mPendingRequestArgs;
Sunny Goyaldedda052019-05-14 15:23:48 -0700363 // Request id for any pending activity result
Sunny Goyal210e1742019-10-17 12:05:38 -0700364 protected int mPendingActivityRequestCode = -1;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800365
Tracy Zhou4d7b2442019-12-09 13:42:57 -0800366 private ViewGroupFocusHelper mFocusHandler;
Hyunyoung Song7fb3ccc2017-10-17 15:39:46 -0700367
Sunny Goyal623eddd2018-03-02 12:24:41 -0800368 private RotationHelper mRotationHelper;
Sunny Goyal7779d622015-06-11 16:18:39 -0700369
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700370 protected LauncherOverlayManager mOverlayManager;
371 // If true, overlay callbacks are deferred
372 private boolean mDeferOverlayCallbacks;
373 private final Runnable mDeferredOverlayCallbacks = this::checkIfOverlayStillDeferred;
374
Riddle Hsu979da642020-09-22 21:52:40 +0800375 protected long mLastTouchUpTime = -1;
Sunny Goyala306e592020-03-24 01:51:41 -0700376 private boolean mTouchInProgress;
Sunny Goyal9b180102020-03-11 10:02:29 -0700377
Samuel Fufa41d909f2020-03-20 16:27:09 -0700378 private SafeCloseable mUserChangedCallbackCloseable;
379
thiruramc96873c2021-02-11 15:13:47 -0800380 // New InstanceId is assigned to mAllAppsSessionLogId for each AllApps sessions.
381 // When Launcher is not in AllApps state mAllAppsSessionLogId will be null.
382 // User actions within AllApps state are logged with this InstanceId, to recreate AllApps
383 // session on the server side.
384 protected InstanceId mAllAppsSessionLogId;
385 private LauncherState mPrevLauncherState;
386
kholoud mohamedc76b2032021-12-20 16:47:38 +0000387 private StringCache mStringCache;
388
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800389 @Override
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -0700390 @TargetApi(Build.VERSION_CODES.S)
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800391 protected void onCreate(Bundle savedInstanceState) {
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -0700392 // Only use a hard-coded cookie since we only want to trace this once.
393 if (Utilities.ATLEAST_S) {
394 Trace.beginAsyncSection(
395 DISPLAY_WORKSPACE_TRACE_METHOD_NAME, DISPLAY_WORKSPACE_TRACE_COOKIE);
396 Trace.beginAsyncSection(DISPLAY_ALL_APPS_TRACE_METHOD_NAME,
397 DISPLAY_ALL_APPS_TRACE_COOKIE);
398 }
Winson Chung5cc62c72019-10-16 11:32:41 -0700399 Object traceToken = TraceHelper.INSTANCE.beginSection(ON_CREATE_EVT,
400 TraceHelper.FLAG_UI_EVENT);
Winson Chunga2413752012-04-03 14:22:34 -0700401 if (DEBUG_STRICT_MODE) {
402 StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
403 .detectDiskReads()
404 .detectDiskWrites()
405 .detectNetwork() // or .detectAll() for all detectable problems
406 .penaltyLog()
407 .build());
408 StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
409 .detectLeakedSqlLiteObjects()
410 .detectLeakedClosableObjects()
411 .penaltyLog()
412 .penaltyDeath()
413 .build());
414 }
415
Tony Wickhame78a70b2021-03-29 16:45:59 -0700416 if (Utilities.IS_DEBUG_DEVICE && FeatureFlags.NOTIFY_CRASHES.get()) {
417 final String notificationChannelId = "com.android.launcher3.Debug";
418 final String notificationChannelName = "Debug";
419 final String notificationTag = "Debug";
420 final int notificationId = 0;
421
422 NotificationManager notificationManager = getSystemService(NotificationManager.class);
423 notificationManager.createNotificationChannel(new NotificationChannel(
424 notificationChannelId, notificationChannelName,
425 NotificationManager.IMPORTANCE_HIGH));
426
427 Thread.currentThread().setUncaughtExceptionHandler((thread, throwable) -> {
428 String stackTrace = Log.getStackTraceString(throwable);
429
430 Intent shareIntent = new Intent(Intent.ACTION_SEND);
431 shareIntent.setType("text/plain");
432 shareIntent.putExtra(Intent.EXTRA_TEXT, stackTrace);
433 shareIntent = Intent.createChooser(shareIntent, null);
434 PendingIntent sharePendingIntent = PendingIntent.getActivity(
435 this, 0, shareIntent, PendingIntent.FLAG_UPDATE_CURRENT
436 );
437
438 Notification notification = new Notification.Builder(this, notificationChannelId)
439 .setSmallIcon(android.R.drawable.ic_menu_close_clear_cancel)
440 .setContentTitle("Launcher crash detected!")
441 .setStyle(new Notification.BigTextStyle().bigText(stackTrace))
442 .addAction(android.R.drawable.ic_menu_share, "Share", sharePendingIntent)
443 .build();
444 notificationManager.notify(notificationTag, notificationId, notification);
445
446 Thread.UncaughtExceptionHandler defaultUncaughtExceptionHandler =
447 Thread.getDefaultUncaughtExceptionHandler();
448 if (defaultUncaughtExceptionHandler != null) {
449 defaultUncaughtExceptionHandler.uncaughtException(thread, throwable);
450 }
451 });
452 }
453
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800454 super.onCreate(savedInstanceState);
Daniel Sandlere060b0b2013-06-27 21:47:55 -0400455
Sunny Goyal87f784c2017-01-11 10:48:34 -0800456 LauncherAppState app = LauncherAppState.getInstance(this);
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800457 mOldConfig = new Configuration(getResources().getConfiguration());
Sunny Goyala7a5bf32020-01-05 15:35:29 +0530458 mModel = app.getModel();
Sunny Goyal9d89f752020-06-19 11:09:24 -0700459
Sunny Goyal41d51a02019-05-14 09:44:34 -0700460 mRotationHelper = new RotationHelper(this);
Hyunyoung Song31971a32019-01-27 12:31:12 -0800461 InvariantDeviceProfile idp = app.getInvariantDeviceProfile();
462 initDeviceProfile(idp);
463 idp.addOnChangeListener(this);
Sunny Goyalf7258242015-10-19 16:59:07 -0700464 mSharedPrefs = Utilities.getPrefs(this);
Joe Onorato0589f0f2010-02-08 13:44:00 -0800465 mIconCache = app.getIconCache();
Sunny Goyal384b5782021-02-09 22:50:02 -0800466 mAccessibilityDelegate = createAccessibilityDelegate();
Adam Cohen2e6da152015-05-06 11:42:25 -0700467
Sunny Goyal59969372021-05-06 12:11:44 -0700468 mDragController = new LauncherDragController(this);
Hyunyoung Song645764e2016-06-06 14:19:02 -0700469 mAllAppsController = new AllAppsTransitionController(this);
Sunny Goyal35e7d382020-05-08 13:37:58 -0700470 mStateManager = new StateManager<>(this, NORMAL);
Romain Guycbb89e42009-06-08 15:52:54 -0700471
Sunny Goyal35e7d382020-05-08 13:37:58 -0700472 mOnboardingPrefs = createOnboardingPrefs(mSharedPrefs);
Tony Wickham133cd542020-04-08 17:48:41 -0700473
Sunny Goyal337c81f2019-12-10 12:19:13 -0800474 mAppWidgetManager = new WidgetManagerHelper(this);
Cyrus Boadway0d309db2021-04-14 12:29:14 +0000475 mAppWidgetHost = createAppWidgetHost();
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700476 mAppWidgetHost.startListening();
Romain Guycbb89e42009-06-08 15:52:54 -0700477
Sunny Goyal9d89f752020-06-19 11:09:24 -0700478 inflateRootView(R.layout.launcher);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800479 setupViews();
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -0700480 crossFadeWithPreviousAppearance();
Sunny Goyal9c2b9602020-01-07 13:07:55 -0800481 mPopupDataProvider = new PopupDataProvider(this::updateNotificationDots);
Tony Wickham010d2552017-01-20 08:15:28 -0800482
Sunny Goyale84c5b82019-09-26 17:05:31 -0700483 boolean internalStateHandled = ACTIVITY_TRACKER.handleCreate(this);
Sunny Goyald3864fa2017-11-14 15:06:36 -0800484 if (internalStateHandled) {
Sunny Goyald3864fa2017-11-14 15:06:36 -0800485 if (savedInstanceState != null) {
486 // InternalStateHandler has already set the appropriate state.
487 // We dont need to do anything.
488 savedInstanceState.remove(RUNTIME_STATE);
489 }
490 }
491 restoreState(savedInstanceState);
Sunny Goyalbbece862019-03-01 13:13:52 -0800492 mStateManager.reapplyState();
Winson Chungb63b44c2017-11-10 17:54:44 -0800493
Sunny Goyalfe770c92016-09-27 14:38:58 -0700494 if (savedInstanceState != null) {
Sunny Goyal12e3f1f2021-07-15 14:31:58 -0700495 int[] pageIds = savedInstanceState.getIntArray(RUNTIME_STATE_CURRENT_SCREEN_IDS);
496 if (pageIds != null) {
497 mPagesToBindSynchronously = IntSet.wrap(pageIds);
498 }
Sunny Goyalfe770c92016-09-27 14:38:58 -0700499 }
Sunny Goyald3864fa2017-11-14 15:06:36 -0800500
Sunny Goyala7a5bf32020-01-05 15:35:29 +0530501 if (!mModel.addCallbacksAndLoad(this)) {
Sunny Goyald3864fa2017-11-14 15:06:36 -0800502 if (!internalStateHandled) {
503 // If we are not binding synchronously, show a fade in animation when
504 // the first page bind completes.
Sunny Goyal6001ea22018-05-10 16:31:00 -0700505 mDragLayer.getAlphaProperty(ALPHA_INDEX_LAUNCHER_LOAD).setValue(0);
Sunny Goyald3864fa2017-11-14 15:06:36 -0800506 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800507 }
508
509 // For handling default keys
Sunny Goyalf4aceab2017-12-06 16:16:31 -0800510 setDefaultKeyMode(DEFAULT_KEYS_SEARCH_LOCAL);
Joe Onorato34a0e1b2009-12-14 17:44:51 -0800511
Sunny Goyal9d89f752020-06-19 11:09:24 -0700512 setContentView(getRootView());
Pinyao Ting85232a92021-12-14 04:36:01 +0000513 getRootView().getViewTreeObserver().addOnPreDrawListener(
514 new ViewTreeObserver.OnPreDrawListener() {
515 @Override
516 public boolean onPreDraw() {
517 // Checks the status of fade in animation.
518 final AlphaProperty property =
519 mDragLayer.getAlphaProperty(ALPHA_INDEX_LAUNCHER_LOAD);
520 if (property.getValue() == 0) {
521 // Animation haven't started yet; suspend.
522 return false;
523 } else {
524 // The animation is started; start drawing.
525 getRootView().getViewTreeObserver().removeOnPreDrawListener(this);
526 return true;
527 }
528 }
529 });
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800530 getRootView().dispatchInsets();
Mario Bertschlera6936942017-05-31 14:48:19 -0700531
Jon Miranda7fda2852017-07-19 16:07:01 -0700532 // Listen for broadcasts
Sunny Goyal5d1873a2018-05-08 11:10:44 -0700533 registerReceiver(mScreenOffReceiver, new IntentFilter(Intent.ACTION_SCREEN_OFF));
Sunny Goyala616d2b2017-06-12 13:54:01 -0700534
Sunny Goyal8392c822017-06-20 10:03:56 -0700535 getSystemUiController().updateUiState(SystemUiController.UI_STATE_BASE_WINDOW,
536 Themes.getAttrBoolean(this, R.attr.isWorkspaceDarkText));
Sunny Goyal14b32402017-07-31 10:03:28 -0700537
538 if (mLauncherCallbacks != null) {
539 mLauncherCallbacks.onCreate(savedInstanceState);
540 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700541 mOverlayManager = getDefaultOverlay();
542 PluginManagerWrapper.INSTANCE.get(this).addPluginListener(this,
Sunny Goyal80a071b2021-12-27 13:30:08 +0530543 LauncherOverlayPlugin.class, false /* allowedMultiple */);
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700544
Sunny Goyal623eddd2018-03-02 12:24:41 -0800545 mRotationHelper.initialize();
Winson Chung5cc62c72019-10-16 11:32:41 -0700546 TraceHelper.INSTANCE.endSection(traceToken);
Samuel Fufa41d909f2020-03-20 16:27:09 -0700547
548 mUserChangedCallbackCloseable = UserCache.INSTANCE.get(this).addUserChangeListener(
549 () -> getStateManager().goToState(NORMAL));
Schneider Victor-tulias8a35c762020-09-03 14:30:10 -0700550
551 if (Utilities.ATLEAST_R) {
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -0700552 getWindow().setSoftInputMode(LayoutParams.SOFT_INPUT_ADJUST_NOTHING);
Schneider Victor-tulias8a35c762020-09-03 14:30:10 -0700553 }
Adam Cohen9211d422014-10-07 18:14:53 -0700554 }
555
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700556 protected LauncherOverlayManager getDefaultOverlay() {
557 return new LauncherOverlayManager() { };
558 }
559
Brian Isganitis099945b2022-01-31 18:15:00 -0500560 protected OnboardingPrefs<? extends Launcher> createOnboardingPrefs(
561 SharedPreferences sharedPrefs) {
Sunny Goyal35e7d382020-05-08 13:37:58 -0700562 return new OnboardingPrefs<>(this, sharedPrefs);
Tony Wickham133cd542020-04-08 17:48:41 -0700563 }
564
Brian Isganitis099945b2022-01-31 18:15:00 -0500565 public OnboardingPrefs<? extends Launcher> getOnboardingPrefs() {
Tony Wickham133cd542020-04-08 17:48:41 -0700566 return mOnboardingPrefs;
567 }
568
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700569 @Override
Sunny Goyal80a071b2021-12-27 13:30:08 +0530570 public void onPluginConnected(LauncherOverlayPlugin overlayManager, Context context) {
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700571 switchOverlay(() -> overlayManager.createOverlayManager(this, this));
572 }
573
574 @Override
Sunny Goyal80a071b2021-12-27 13:30:08 +0530575 public void onPluginDisconnected(LauncherOverlayPlugin plugin) {
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700576 switchOverlay(this::getDefaultOverlay);
577 }
578
579 private void switchOverlay(Supplier<LauncherOverlayManager> overlaySupplier) {
580 if (mOverlayManager != null) {
581 mOverlayManager.onActivityDestroyed(this);
582 }
583 mOverlayManager = overlaySupplier.get();
584 if (getRootView().isAttachedToWindow()) {
585 mOverlayManager.onAttachedToWindow();
586 }
587 mDeferOverlayCallbacks = true;
588 checkIfOverlayStillDeferred();
589 }
590
591 @Override
Brian Isganitis099945b2022-01-31 18:15:00 -0500592 public void dispatchDeviceProfileChanged() {
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700593 super.dispatchDeviceProfileChanged();
594 mOverlayManager.onDeviceProvideChanged();
595 }
596
Sunny Goyal7779d622015-06-11 16:18:39 -0700597 @Override
Winson Chung8eb49e02018-07-16 13:33:31 -0700598 public void onEnterAnimationComplete() {
599 super.onEnterAnimationComplete();
Sunny Goyalbe8c3402019-05-22 15:17:52 -0700600 mRotationHelper.setCurrentTransitionRequest(REQUEST_NONE);
Sunny Goyal30ac97d2020-06-24 23:47:46 -0700601 AbstractFloatingView.closeOpenViews(this, false, TYPE_ICON_SURFACE);
Winson Chung8eb49e02018-07-16 13:33:31 -0700602 }
603
604 @Override
Jerry Chang09b40242021-08-27 13:29:01 +0800605 public void onMultiWindowModeChanged(boolean isInMultiWindowMode, Configuration newConfig) {
606 super.onMultiWindowModeChanged(isInMultiWindowMode, newConfig);
607 // Always update device profile when multi window mode changed.
608 initDeviceProfile(mDeviceProfile.inv);
609 dispatchDeviceProfileChanged();
610 }
611
612 @Override
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800613 public void onConfigurationChanged(Configuration newConfig) {
614 int diff = newConfig.diff(mOldConfig);
615 if ((diff & (CONFIG_ORIENTATION | CONFIG_SCREEN_SIZE)) != 0) {
Sunny Goyal6e6f7992021-08-24 16:23:29 -0700616 onIdpChanged(false);
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800617 }
618
619 mOldConfig.setTo(newConfig);
620 super.onConfigurationChanged(newConfig);
621 }
622
Sunny Goyal605bcf32018-03-02 15:16:12 -0800623 @Override
Sunny Goyal6e6f7992021-08-24 16:23:29 -0700624 public void onIdpChanged(boolean modelPropertiesChanged) {
625 initDeviceProfile(mDeviceProfile.inv);
Sunny Goyal371ea052019-03-06 15:38:32 -0800626 dispatchDeviceProfileChanged();
627 reapplyUi();
628 mDragLayer.recreateControllers();
629
Sunny Goyal76ba0a32019-06-10 11:56:11 -0700630 // Calling onSaveInstanceState ensures that static cache used by listWidgets is
631 // initialized properly.
632 onSaveInstanceState(new Bundle());
Sunny Goyalc4d32012020-04-03 17:10:11 -0700633 mModel.rebindCallbacks();
Hyunyoung Song31971a32019-01-27 12:31:12 -0800634 }
635
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400636 public void onAssistantVisibilityChanged(float visibility) {
Sunny Goyal0b5b8d42021-03-31 14:56:47 -0700637 mHotseat.getQsb().setAlpha(1f - visibility);
Govinda Wassermanc06e1512019-04-09 09:56:53 -0400638 }
639
Bill Lina1221bc2021-06-03 01:49:27 +0800640 /**
641 * Called when one handed mode activated and deactivated.
642 * @param activated true if one handed mode activated, false otherwise.
643 */
644 public void onOneHandedStateChanged(boolean activated) {
645 mDragLayer.onOneHandedModeStateChanged(activated);
646 }
647
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800648 private void initDeviceProfile(InvariantDeviceProfile idp) {
649 // Load configuration-specific DeviceProfile
Jerry Changbfac46a2021-09-08 08:20:58 +0800650 mDeviceProfile = idp.getDeviceProfile(this);
651 if (isInMultiWindowMode()) {
652 mDeviceProfile = mDeviceProfile.getMultiWindowProfile(
653 this, getMultiWindowDisplaySize());
654 }
Sunny Goyalae6e3182019-04-30 12:04:37 -0700655
Sunny Goyal59d086c2018-05-07 17:31:40 -0700656 onDeviceProfileInitiated();
Sunny Goyal711c5962021-06-23 12:36:18 -0700657 mModelWriter = mModel.getWriter(getDeviceProfile().isVerticalBarLayout(), true, this);
Sunny Goyalf8d56fc2018-01-31 15:18:11 -0800658 }
659
Sunny Goyal623eddd2018-03-02 12:24:41 -0800660 public RotationHelper getRotationHelper() {
661 return mRotationHelper;
662 }
663
Tracy Zhou4d7b2442019-12-09 13:42:57 -0800664 public ViewGroupFocusHelper getFocusHandler() {
665 return mFocusHandler;
666 }
667
Sunny Goyal35e7d382020-05-08 13:37:58 -0700668 @Override
669 public StateManager<LauncherState> getStateManager() {
Sunny Goyal3e3f44c2017-10-23 17:14:52 -0700670 return mStateManager;
Sunny Goyalbe93f262017-10-20 17:05:27 -0700671 }
672
Adam Cohen9211d422014-10-07 18:14:53 -0700673 private LauncherCallbacks mLauncherCallbacks;
674
Sunny Goyal32554d12015-12-03 15:31:25 -0800675 /**
676 * Call this after onCreate to set or clear overlay.
677 */
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700678 @Override
Sunny Goyal32554d12015-12-03 15:31:25 -0800679 public void setLauncherOverlay(LauncherOverlay overlay) {
680 if (overlay != null) {
Lucas Dupin87d75202021-07-28 10:24:54 -0700681 overlay.setOverlayCallbacks(this);
Sunny Goyal32554d12015-12-03 15:31:25 -0800682 }
683 mWorkspace.setLauncherOverlay(overlay);
684 }
685
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700686 @Override
687 public void runOnOverlayHidden(Runnable runnable) {
688 getWorkspace().runOnOverlayHidden(runnable);
689 }
690
Adam Cohen9211d422014-10-07 18:14:53 -0700691 public boolean setLauncherCallbacks(LauncherCallbacks callbacks) {
692 mLauncherCallbacks = callbacks;
693 return true;
Adam Cohenf9426d52012-06-04 17:26:21 -0700694 }
695
Hyunyoung Song3f471442015-04-08 19:01:34 -0700696 public boolean isDraggingEnabled() {
Winson Chung36a62fe2012-05-06 18:04:42 -0700697 // We prevent dragging when we are loading the workspace as it is possible to pick up a view
698 // that is subsequently removed from the workspace in startBinding().
Sunny Goyal639e9062015-08-19 19:17:06 -0700699 return !isWorkspaceLoading();
Winson Chung36a62fe2012-05-06 18:04:42 -0700700 }
701
Schneider Victor-tulias5173fd82021-10-19 14:47:23 -0700702 @NonNull
703 @Override
Tony Wickham010d2552017-01-20 08:15:28 -0800704 public PopupDataProvider getPopupDataProvider() {
705 return mPopupDataProvider;
706 }
707
Sunny Goyal0b0847b2018-03-14 12:30:11 -0700708 @Override
Tony Wickhamf34bee82018-12-03 18:11:39 -0800709 public DotInfo getDotInfoForItem(ItemInfo info) {
710 return mPopupDataProvider.getDotInfoForItem(info);
Sunny Goyal0b0847b2018-03-14 12:30:11 -0700711 }
712
713 @Override
714 public void invalidateParent(ItemInfo info) {
Jon Mirandae6f3fa42019-03-04 09:14:40 -0800715 if (info.container >= 0) {
Sunny Goyal0b0847b2018-03-14 12:30:11 -0700716 View folderIcon = getWorkspace().getHomescreenIconByItemId(info.container);
Jon Mirandae6f3fa42019-03-04 09:14:40 -0800717 if (folderIcon instanceof FolderIcon && folderIcon.getTag() instanceof FolderInfo) {
Sunny Goyal11a50742019-08-07 09:24:26 -0700718 if (new FolderGridOrganizer(getDeviceProfile().inv)
719 .setFolderInfo((FolderInfo) folderIcon.getTag())
720 .isItemInPreview(info.rank)) {
Jon Mirandae6f3fa42019-03-04 09:14:40 -0800721 folderIcon.invalidate();
722 }
Sunny Goyal0b0847b2018-03-14 12:30:11 -0700723 }
724 }
725 }
726
Adam Cohenc76e1dd2013-11-14 11:09:14 +0000727 /**
Winson Chung557d6ed2011-07-08 15:34:52 -0700728 * Returns whether we should delay spring loaded mode -- for shortcuts and widgets that have
729 * a configuration step, this allows the proper animations to run after other transitions.
730 */
Sunny Goyalefb7e842018-10-04 15:11:00 -0700731 private int completeAdd(
Sunny Goyal2100c782016-08-22 16:00:03 -0700732 int requestCode, Intent intent, int appWidgetId, PendingRequestArgs info) {
Sunny Goyalefb7e842018-10-04 15:11:00 -0700733 int screenId = info.screenId;
Sunny Goyal2100c782016-08-22 16:00:03 -0700734 if (info.container == LauncherSettings.Favorites.CONTAINER_DESKTOP) {
Adam Cohen83079e42014-09-19 17:43:08 -0700735 // When the screen id represents an actual screen (as opposed to a rank) we make sure
736 // that the drop page actually exists.
Sunny Goyal2100c782016-08-22 16:00:03 -0700737 screenId = ensurePendingDropLayoutExists(info.screenId);
Adam Cohen83079e42014-09-19 17:43:08 -0700738 }
Adam Cohendb364c32014-05-20 14:23:40 -0700739
Sunny Goyal2100c782016-08-22 16:00:03 -0700740 switch (requestCode) {
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800741 case REQUEST_CREATE_SHORTCUT:
Sunny Goyalfb5096d2016-09-08 14:32:06 -0700742 completeAddShortcut(intent, info.container, screenId, info.cellX, info.cellY, info);
Pinyao Tingc9074272019-11-11 11:51:44 -0800743 announceForAccessibility(R.string.item_added_to_workspace);
Winson Chungb8472bb2011-08-05 13:49:21 -0700744 break;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800745 case REQUEST_CREATE_APPWIDGET:
Sunny Goyal2100c782016-08-22 16:00:03 -0700746 completeAddAppWidget(appWidgetId, info, null, null);
Winson Chungb8472bb2011-08-05 13:49:21 -0700747 break;
Sunny Goyalff572272014-07-23 13:58:07 -0700748 case REQUEST_RECONFIGURE_APPWIDGET:
Yogisha Dixit4ff5ee32021-05-04 14:58:34 +0100749 mStatsLogManager.logger().withItemInfo(info).log(LAUNCHER_WIDGET_RECONFIGURED);
Sunny Goyal2100c782016-08-22 16:00:03 -0700750 completeRestoreAppWidget(appWidgetId, LauncherAppWidgetInfo.RESTORE_COMPLETED);
Sunny Goyalff572272014-07-23 13:58:07 -0700751 break;
Sunny Goyald478c832016-04-01 12:04:16 -0700752 case REQUEST_BIND_PENDING_APPWIDGET: {
Sunny Goyal2100c782016-08-22 16:00:03 -0700753 int widgetId = appWidgetId;
754 LauncherAppWidgetInfo widgetInfo =
Sunny Goyald478c832016-04-01 12:04:16 -0700755 completeRestoreAppWidget(widgetId, LauncherAppWidgetInfo.FLAG_UI_NOT_READY);
Sunny Goyal2100c782016-08-22 16:00:03 -0700756 if (widgetInfo != null) {
Sunny Goyald478c832016-04-01 12:04:16 -0700757 // Since the view was just bound, also launch the configure activity if needed
758 LauncherAppWidgetProviderInfo provider = mAppWidgetManager
759 .getLauncherAppWidgetInfo(widgetId);
Sunny Goyal04a324a2017-01-20 21:08:59 -0800760 if (provider != null) {
761 new WidgetAddFlowHandler(provider)
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700762 .startConfigActivity(this, widgetInfo,
763 REQUEST_RECONFIGURE_APPWIDGET);
Sunny Goyald478c832016-04-01 12:04:16 -0700764 }
765 }
766 break;
767 }
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800768 }
Adam Cohendb364c32014-05-20 14:23:40 -0700769 return screenId;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800770 }
771
Adam Cohenc7cd2cb2014-11-17 17:45:34 -0800772 private void handleActivityResult(
Michael Jurka8b805b12012-04-18 14:23:14 -0700773 final int requestCode, final int resultCode, final Intent data) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700774 if (isWorkspaceLoading()) {
775 // process the result once the workspace has loaded.
776 mPendingActivityResult = new ActivityResultInfo(requestCode, resultCode, data);
777 return;
778 }
779 mPendingActivityResult = null;
780
Winson Chunge341d302013-08-16 14:31:00 -0700781 // Reset the startActivity waiting flag
Sunny Goyal2100c782016-08-22 16:00:03 -0700782 final PendingRequestArgs requestArgs = mPendingRequestArgs;
783 setWaitingForResult(null);
784 if (requestArgs == null) {
785 return;
786 }
787
788 final int pendingAddWidgetId = requestArgs.getWidgetId();
Winson Chunge341d302013-08-16 14:31:00 -0700789
Adam Cohenad4e15c2013-10-17 16:21:35 -0700790 Runnable exitSpringLoaded = new Runnable() {
791 @Override
792 public void run() {
Sunny Goyal3e3f44c2017-10-23 17:14:52 -0700793 mStateManager.goToState(NORMAL, SPRING_LOADED_EXIT_DELAY);
Adam Cohenad4e15c2013-10-17 16:21:35 -0700794 }
795 };
796
Michael Jurka8b805b12012-04-18 14:23:14 -0700797 if (requestCode == REQUEST_BIND_APPWIDGET) {
Winsona1f79d32015-08-05 14:00:45 -0700798 // This is called only if the user did not previously have permissions to bind widgets
Adam Cohenad4e15c2013-10-17 16:21:35 -0700799 final int appWidgetId = data != null ?
Michael Jurka8b805b12012-04-18 14:23:14 -0700800 data.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1) : -1;
801 if (resultCode == RESULT_CANCELED) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700802 completeTwoStageWidgetDrop(RESULT_CANCELED, appWidgetId, requestArgs);
Sunny Goyal6e379fc2020-03-19 16:08:14 -0700803 mWorkspace.removeExtraEmptyScreenDelayed(
804 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false, exitSpringLoaded);
Michael Jurka8b805b12012-04-18 14:23:14 -0700805 } else if (resultCode == RESULT_OK) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700806 addAppWidgetImpl(
807 appWidgetId, requestArgs, null,
Sunny Goyal04a324a2017-01-20 21:08:59 -0800808 requestArgs.getWidgetHandler(),
Sunny Goyal2100c782016-08-22 16:00:03 -0700809 ON_ACTIVITY_RESULT_ANIMATION_DELAY);
Michael Jurka8b805b12012-04-18 14:23:14 -0700810 }
811 return;
812 }
Michael Jurka336fd4f2013-09-12 00:05:02 +0200813
Adam Cohened66b2b2012-01-23 17:28:51 -0800814 boolean isWidgetDrop = (requestCode == REQUEST_PICK_APPWIDGET ||
Sunny Goyal5c97f512015-05-19 16:03:28 -0700815 requestCode == REQUEST_CREATE_APPWIDGET);
Romain Guyaad5ef42009-06-10 02:48:37 -0700816
Adam Cohened66b2b2012-01-23 17:28:51 -0800817 // We have special handling for widgets
818 if (isWidgetDrop) {
Adam Cohen4637b5a2013-11-04 18:21:24 -0800819 final int appWidgetId;
820 int widgetId = data != null ? data.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1)
821 : -1;
822 if (widgetId < 0) {
823 appWidgetId = pendingAddWidgetId;
824 } else {
825 appWidgetId = widgetId;
826 }
827
Adam Cohenad4e15c2013-10-17 16:21:35 -0700828 final int result;
Adam Cohenf0129b12013-11-04 17:57:36 -0800829 if (appWidgetId < 0 || resultCode == RESULT_CANCELED) {
Adam Cohendb364c32014-05-20 14:23:40 -0700830 Log.e(TAG, "Error: appWidgetId (EXTRA_APPWIDGET_ID) was not " +
831 "returned from the widget configuration activity.");
Adam Cohenad4e15c2013-10-17 16:21:35 -0700832 result = RESULT_CANCELED;
Sunny Goyal2100c782016-08-22 16:00:03 -0700833 completeTwoStageWidgetDrop(result, appWidgetId, requestArgs);
Sunny Goyal6e379fc2020-03-19 16:08:14 -0700834 mWorkspace.removeExtraEmptyScreenDelayed(
835 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false,
836 () -> getStateManager().goToState(NORMAL));
Sunny Goyal2100c782016-08-22 16:00:03 -0700837 } else {
838 if (requestArgs.container == LauncherSettings.Favorites.CONTAINER_DESKTOP) {
839 // When the screen id represents an actual screen (as opposed to a rank)
840 // we make sure that the drop page actually exists.
841 requestArgs.screenId =
842 ensurePendingDropLayoutExists(requestArgs.screenId);
Adam Cohendb364c32014-05-20 14:23:40 -0700843 }
Sunny Goyal2100c782016-08-22 16:00:03 -0700844 final CellLayout dropLayout =
845 mWorkspace.getScreenWithId(requestArgs.screenId);
846
847 dropLayout.setDropPending(true);
848 final Runnable onComplete = new Runnable() {
849 @Override
850 public void run() {
851 completeTwoStageWidgetDrop(resultCode, appWidgetId, requestArgs);
852 dropLayout.setDropPending(false);
853 }
854 };
Sunny Goyal6e379fc2020-03-19 16:08:14 -0700855 mWorkspace.removeExtraEmptyScreenDelayed(
856 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false, onComplete);
Winson Chung5aaab772012-04-27 15:24:02 -0700857 }
Adam Cohened66b2b2012-01-23 17:28:51 -0800858 return;
859 }
860
Sunny Goyald478c832016-04-01 12:04:16 -0700861 if (requestCode == REQUEST_RECONFIGURE_APPWIDGET
862 || requestCode == REQUEST_BIND_PENDING_APPWIDGET) {
Sunny Goyalff572272014-07-23 13:58:07 -0700863 if (resultCode == RESULT_OK) {
864 // Update the widget view.
Sunny Goyal2100c782016-08-22 16:00:03 -0700865 completeAdd(requestCode, data, pendingAddWidgetId, requestArgs);
Sunny Goyalff572272014-07-23 13:58:07 -0700866 }
867 // Leave the widget in the pending state if the user canceled the configure.
868 return;
869 }
870
Sunny Goyalaad90582015-07-09 14:22:50 -0700871 if (requestCode == REQUEST_CREATE_SHORTCUT) {
872 // Handle custom shortcuts created using ACTION_CREATE_SHORTCUT.
Sunny Goyal2100c782016-08-22 16:00:03 -0700873 if (resultCode == RESULT_OK && requestArgs.container != ItemInfo.NO_ID) {
874 completeAdd(requestCode, data, -1, requestArgs);
Sunny Goyal6e379fc2020-03-19 16:08:14 -0700875 mWorkspace.removeExtraEmptyScreenDelayed(
876 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false, exitSpringLoaded);
Sunny Goyal2100c782016-08-22 16:00:03 -0700877
Sunny Goyalaad90582015-07-09 14:22:50 -0700878 } else if (resultCode == RESULT_CANCELED) {
Sunny Goyal6e379fc2020-03-19 16:08:14 -0700879 mWorkspace.removeExtraEmptyScreenDelayed(
880 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false, exitSpringLoaded);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800881 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800882 }
Hongming Jind91cb6e2020-01-27 16:23:03 -0800883
Adam Cohened66b2b2012-01-23 17:28:51 -0800884 mDragLayer.clearAnimatedView();
Adam Cohenc7cd2cb2014-11-17 17:45:34 -0800885 }
886
887 @Override
Sunny Goyal64a75aa2017-07-03 13:50:52 -0700888 public void onActivityResult(
Adam Cohenc7cd2cb2014-11-17 17:45:34 -0800889 final int requestCode, final int resultCode, final Intent data) {
Sunny Goyaldedda052019-05-14 15:23:48 -0700890 mPendingActivityRequestCode = -1;
Adam Cohenc7cd2cb2014-11-17 17:45:34 -0800891 handleActivityResult(requestCode, resultCode, data);
Adam Cohened66b2b2012-01-23 17:28:51 -0800892 }
893
Sunny Goyal7ce471b2017-08-02 03:37:39 -0700894 @Override
Sunny Goyaldd2e6df2015-07-07 10:57:57 -0700895 public void onRequestPermissionsResult(int requestCode, String[] permissions,
Dave Hawkey3a43ed62015-06-26 10:27:47 -0600896 int[] grantResults) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700897 PendingRequestArgs pendingArgs = mPendingRequestArgs;
898 if (requestCode == REQUEST_PERMISSION_CALL_PHONE && pendingArgs != null
899 && pendingArgs.getRequestCode() == REQUEST_PERMISSION_CALL_PHONE) {
900 setWaitingForResult(null);
901
Sunny Goyal28c6b962015-10-12 11:42:05 -0700902 View v = null;
Sunny Goyal2100c782016-08-22 16:00:03 -0700903 CellLayout layout = getCellLayout(pendingArgs.container, pendingArgs.screenId);
Sunny Goyal28c6b962015-10-12 11:42:05 -0700904 if (layout != null) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700905 v = layout.getChildAt(pendingArgs.cellX, pendingArgs.cellY);
Sunny Goyal28c6b962015-10-12 11:42:05 -0700906 }
Sunny Goyal2100c782016-08-22 16:00:03 -0700907 Intent intent = pendingArgs.getPendingIntent();
908
Sunny Goyal28c6b962015-10-12 11:42:05 -0700909 if (grantResults.length > 0
910 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
Sunny Goyal852537f2020-07-15 17:02:16 -0700911 startActivitySafely(v, intent, null);
Sunny Goyal28c6b962015-10-12 11:42:05 -0700912 } else {
913 // TODO: Show a snack bar with link to settings
914 Toast.makeText(this, getString(R.string.msg_no_phone_permission,
Sunny Goyal112ce422016-08-22 16:45:29 -0700915 getString(R.string.derived_app_name)), Toast.LENGTH_SHORT).show();
Sunny Goyal28c6b962015-10-12 11:42:05 -0700916 }
917 }
Dave Hawkey3a43ed62015-06-26 10:27:47 -0600918 }
919
Adam Cohendb364c32014-05-20 14:23:40 -0700920 /**
921 * Check to see if a given screen id exists. If not, create it at the end, return the new id.
922 *
923 * @param screenId the screen id to check
924 * @return the new screen, or screenId if it exists
925 */
Sunny Goyalefb7e842018-10-04 15:11:00 -0700926 private int ensurePendingDropLayoutExists(int screenId) {
Sunny Goyal32554d12015-12-03 15:31:25 -0800927 CellLayout dropLayout = mWorkspace.getScreenWithId(screenId);
Adam Cohendb364c32014-05-20 14:23:40 -0700928 if (dropLayout == null) {
929 // it's possible that the add screen was removed because it was
930 // empty and a re-bind occurred
Andras Kloczl408a54f2021-08-28 00:59:08 +0100931 mWorkspace.addExtraEmptyScreens();
932 IntSet emptyPagesAdded = mWorkspace.commitExtraEmptyScreens();
933 return emptyPagesAdded.isEmpty() ? -1 : emptyPagesAdded.getArray().get(0);
Adam Cohendb364c32014-05-20 14:23:40 -0700934 }
Andras Kloczl408a54f2021-08-28 00:59:08 +0100935 return screenId;
Adam Cohendb364c32014-05-20 14:23:40 -0700936 }
937
Samuel Fufaca37b8a2019-08-19 17:04:36 -0700938 @Thunk
939 void completeTwoStageWidgetDrop(
Sunny Goyal2100c782016-08-22 16:00:03 -0700940 final int resultCode, final int appWidgetId, final PendingRequestArgs requestArgs) {
941 CellLayout cellLayout = mWorkspace.getScreenWithId(requestArgs.screenId);
Adam Cohened66b2b2012-01-23 17:28:51 -0800942 Runnable onCompleteRunnable = null;
943 int animationType = 0;
944
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700945 AppWidgetHostView boundWidget = null;
Adam Cohened66b2b2012-01-23 17:28:51 -0800946 if (resultCode == RESULT_OK) {
947 animationType = Workspace.COMPLETE_TWO_STAGE_WIDGET_DROP_ANIMATION;
948 final AppWidgetHostView layout = mAppWidgetHost.createView(this, appWidgetId,
Sunny Goyal04a324a2017-01-20 21:08:59 -0800949 requestArgs.getWidgetHandler().getProviderInfo(this));
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700950 boundWidget = layout;
Adam Cohened66b2b2012-01-23 17:28:51 -0800951 onCompleteRunnable = new Runnable() {
952 @Override
953 public void run() {
Sunny Goyal2100c782016-08-22 16:00:03 -0700954 completeAddAppWidget(appWidgetId, requestArgs, layout, null);
Sunny Goyal3e3f44c2017-10-23 17:14:52 -0700955 mStateManager.goToState(NORMAL, SPRING_LOADED_EXIT_DELAY);
Adam Cohened66b2b2012-01-23 17:28:51 -0800956 }
957 };
958 } else if (resultCode == RESULT_CANCELED) {
Adam Cohen4637b5a2013-11-04 18:21:24 -0800959 mAppWidgetHost.deleteAppWidgetId(appWidgetId);
Adam Cohened66b2b2012-01-23 17:28:51 -0800960 animationType = Workspace.CANCEL_TWO_STAGE_WIDGET_DROP_ANIMATION;
Adam Cohened66b2b2012-01-23 17:28:51 -0800961 }
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700962 if (mDragLayer.getAnimatedView() != null) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700963 mWorkspace.animateWidgetDrop(requestArgs, cellLayout,
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700964 (DragView) mDragLayer.getAnimatedView(), onCompleteRunnable,
965 animationType, boundWidget, true);
Adam Cohenad4e15c2013-10-17 16:21:35 -0700966 } else if (onCompleteRunnable != null) {
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700967 // The animated view may be null in the case of a rotation during widget configuration
968 onCompleteRunnable.run();
969 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800970 }
971
972 @Override
Michael Jurkacd496d72013-04-11 11:32:45 -0700973 protected void onStop() {
974 super.onStop();
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700975 if (mDeferOverlayCallbacks) {
976 checkIfOverlayStillDeferred();
977 } else {
978 mOverlayManager.onActivityStopped(this);
Adam Cohen9211d422014-10-07 18:14:53 -0700979 }
Hyunyoung Song5ee7c132021-05-11 13:52:36 -0700980 hideKeyboard();
Hyunyoung Song95786e02020-09-15 00:34:10 -0700981 logStopAndResume(false /* isResume */);
vadimt04ebcf42021-02-03 15:31:51 -0800982 mAppWidgetHost.setActivityStarted(false);
Schneider Victor-tulias5173fd82021-10-19 14:47:23 -0700983 NotificationListener.removeNotificationsChangedListener(getPopupDataProvider());
Michael Jurkacd496d72013-04-11 11:32:45 -0700984 }
985
986 @Override
987 protected void onStart() {
Winson Chung5cc62c72019-10-16 11:32:41 -0700988 Object traceToken = TraceHelper.INSTANCE.beginSection(ON_START_EVT,
989 TraceHelper.FLAG_UI_EVENT);
Michael Jurkacd496d72013-04-11 11:32:45 -0700990 super.onStart();
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700991 if (!mDeferOverlayCallbacks) {
992 mOverlayManager.onActivityStarted(this);
Adam Cohen9211d422014-10-07 18:14:53 -0700993 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -0700994
vadimt04ebcf42021-02-03 15:31:51 -0800995 mAppWidgetHost.setActivityStarted(true);
Winson Chung5cc62c72019-10-16 11:32:41 -0700996 TraceHelper.INSTANCE.endSection(traceToken);
Michael Jurkacd496d72013-04-11 11:32:45 -0700997 }
998
Sunny Goyal35e7d382020-05-08 13:37:58 -0700999 @Override
1000 @CallSuper
1001 protected void onDeferredResumed() {
Hyunyoung Song95786e02020-09-15 00:34:10 -07001002 logStopAndResume(true /* isResume */);
Sunny Goyala002c6c2019-02-12 16:20:10 -08001003
Sunny Goyal35e7d382020-05-08 13:37:58 -07001004 // Process any items that were added while Launcher was away.
Sunny Goyal60e68c92020-08-12 13:59:27 -07001005 ItemInstallQueue.INSTANCE.get(this)
1006 .resumeModelPush(FLAG_ACTIVITY_PAUSED);
Sunny Goyale9c6f4c2019-05-30 11:35:25 -07001007
Sunny Goyal35e7d382020-05-08 13:37:58 -07001008 // Refresh shortcuts if the permission changed.
Sunny Goyal8b74cc72020-07-27 17:50:33 -07001009 mModel.validateModelDataOnResume();
Sunny Goyale9c6f4c2019-05-30 11:35:25 -07001010
Sunny Goyal35e7d382020-05-08 13:37:58 -07001011 // Set the notification listener and fetch updated notifications when we resume
Schneider Victor-tulias5173fd82021-10-19 14:47:23 -07001012 NotificationListener.addNotificationsChangedListener(mPopupDataProvider);
Winson Chung87583112019-06-10 14:20:58 -07001013
Sunny Goyal35e7d382020-05-08 13:37:58 -07001014 DiscoveryBounce.showForHomeIfNeeded(this);
vadimt04ebcf42021-02-03 15:31:51 -08001015 mAppWidgetHost.setActivityResumed(true);
Sunny Goyaldedda052019-05-14 15:23:48 -07001016 }
1017
Hyunyoung Song95786e02020-09-15 00:34:10 -07001018 private void logStopAndResume(boolean isResume) {
Hyunyoung Song77e29772020-08-25 00:53:48 -07001019 if (mPendingExecutor != null) return;
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001020 int pageIndex = mWorkspace.isOverlayShown() ? -1 : mWorkspace.getCurrentPage();
Hyunyoung Song95786e02020-09-15 00:34:10 -07001021 int statsLogOrdinal = mStateManager.getState().statsLogOrdinal;
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001022
1023 StatsLogManager.EventEnum event;
1024 StatsLogManager.StatsLogger logger = getStatsLogManager().logger();
Hyunyoung Song95786e02020-09-15 00:34:10 -07001025 if (isResume) {
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001026 logger.withSrcState(LAUNCHER_STATE_BACKGROUND)
Hyunyoung Song95786e02020-09-15 00:34:10 -07001027 .withDstState(mStateManager.getState().statsLogOrdinal);
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001028 event = LAUNCHER_ONRESUME;
1029 } else { /* command == Action.Command.STOP */
Hyunyoung Song95786e02020-09-15 00:34:10 -07001030 logger.withSrcState(mStateManager.getState().statsLogOrdinal)
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001031 .withDstState(LAUNCHER_STATE_BACKGROUND);
1032 event = LAUNCHER_ONSTOP;
1033 }
1034
Hyunyoung Song95786e02020-09-15 00:34:10 -07001035 if (statsLogOrdinal == LAUNCHER_STATE_HOME && mWorkspace != null) {
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001036 logger.withContainerInfo(LauncherAtom.ContainerInfo.newBuilder()
1037 .setWorkspace(
1038 LauncherAtom.WorkspaceContainer.newBuilder()
1039 .setPageIndex(pageIndex)).build());
Becky Qiubfc2da12019-08-01 11:09:38 -07001040 }
Hyunyoung Song801f81f2020-06-19 02:58:53 -07001041 logger.log(event);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001042 }
Becky Qiubfc2da12019-08-01 11:09:38 -07001043
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001044 private void scheduleDeferredCheck() {
1045 mHandler.removeCallbacks(mDeferredOverlayCallbacks);
1046 postAsyncCallback(mHandler, mDeferredOverlayCallbacks);
1047 }
1048
1049 private void checkIfOverlayStillDeferred() {
1050 if (!mDeferOverlayCallbacks) {
1051 return;
1052 }
Sunny Goyal8f965462020-04-23 19:00:36 -07001053 if (isStarted() && (!hasBeenResumed()
1054 || mStateManager.getState().hasFlag(FLAG_NON_INTERACTIVE))) {
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001055 return;
1056 }
1057 mDeferOverlayCallbacks = false;
1058
1059 // Move the client to the correct state. Calling the same method twice is no-op.
1060 if (isStarted()) {
1061 mOverlayManager.onActivityStarted(this);
1062 }
1063 if (hasBeenResumed()) {
1064 mOverlayManager.onActivityResumed(this);
1065 } else {
1066 mOverlayManager.onActivityPaused(this);
1067 }
1068 if (!isStarted()) {
1069 mOverlayManager.onActivityStopped(this);
1070 }
1071 }
1072
1073 public void deferOverlayCallbacksUntilNextResumeOrStop() {
1074 mDeferOverlayCallbacks = true;
1075 }
1076
1077 public LauncherOverlayManager getOverlayManager() {
1078 return mOverlayManager;
Becky Qiubfc2da12019-08-01 11:09:38 -07001079 }
1080
Sunny Goyal35e7d382020-05-08 13:37:58 -07001081 @Override
Winson Chungef528762019-09-06 12:05:52 -07001082 public void onStateSetStart(LauncherState state) {
Sunny Goyal35e7d382020-05-08 13:37:58 -07001083 super.onStateSetStart(state);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001084 if (mDeferOverlayCallbacks) {
1085 scheduleDeferredCheck();
Sunny Goyale9c6f4c2019-05-30 11:35:25 -07001086 }
Sunny Goyal210e1742019-10-17 12:05:38 -07001087 addActivityFlags(ACTIVITY_STATE_TRANSITION_ACTIVE);
Sunny Goyal8f965462020-04-23 19:00:36 -07001088
1089 if (state.hasFlag(FLAG_CLOSE_POPUPS)) {
1090 AbstractFloatingView.closeAllOpenViews(this, !state.hasFlag(FLAG_NON_INTERACTIVE));
1091 }
1092
1093 if (state == SPRING_LOADED) {
1094 // Prevent any Un/InstallShortcutReceivers from updating the db while we are
1095 // not on homescreen
Sunny Goyal60e68c92020-08-12 13:59:27 -07001096 ItemInstallQueue.INSTANCE.get(this).pauseModelPush(FLAG_DRAG_AND_DROP);
Sunny Goyal8f965462020-04-23 19:00:36 -07001097 getRotationHelper().setCurrentStateRequest(REQUEST_LOCK);
1098
1099 mWorkspace.showPageIndicatorAtCurrentScroll();
1100 mWorkspace.setClipChildren(false);
1101 }
1102 // When multiple pages are visible, show persistent page indicator
1103 mWorkspace.getPageIndicator().setShouldAutoHide(!state.hasFlag(FLAG_MULTI_PAGE));
thiruram0eabc782021-04-02 14:30:10 -07001104
thiruramc96873c2021-02-11 15:13:47 -08001105 mPrevLauncherState = mStateManager.getCurrentStableState();
thiruram0eabc782021-04-02 14:30:10 -07001106 if (mPrevLauncherState != state && ALL_APPS.equals(state)
1107 // Making sure mAllAppsSessionLogId is null to avoid double logging.
1108 && mAllAppsSessionLogId == null) {
1109 // creates new instance ID since new all apps session is started.
1110 mAllAppsSessionLogId = new InstanceIdSequence().newInstanceId();
Thiru Ramasamy5fbac632022-01-28 15:05:36 -08001111 getStatsLogManager().logger().withContainerInfo(
1112 ContainerInfo.newBuilder().setWorkspace(
1113 WorkspaceContainer.newBuilder().setPageIndex(
1114 getWorkspace().getCurrentPage())).build())
1115 .log(getAllAppsEntryEvent());
thiruram0eabc782021-04-02 14:30:10 -07001116 }
Sunny Goyaldedda052019-05-14 15:23:48 -07001117 }
1118
Thiru Ramasamy5fbac632022-01-28 15:05:36 -08001119 /**
1120 * Returns {@link EventEnum} that should be logged when Launcher enters into AllApps state.
1121 */
1122 protected EventEnum getAllAppsEntryEvent() {
1123 return FeatureFlags.ENABLE_DEVICE_SEARCH.get()
1124 ? LAUNCHER_ALLAPPS_ENTRY_WITH_DEVICE_SEARCH
1125 : LAUNCHER_ALLAPPS_ENTRY;
1126 }
1127
Sunny Goyal35e7d382020-05-08 13:37:58 -07001128 @Override
Winson Chungef528762019-09-06 12:05:52 -07001129 public void onStateSetEnd(LauncherState state) {
Sunny Goyalfee1b252020-12-14 12:30:38 -08001130 super.onStateSetEnd(state);
vadimt04ebcf42021-02-03 15:31:51 -08001131 getAppWidgetHost().setStateIsNormal(state == LauncherState.NORMAL);
Sunny Goyal8f965462020-04-23 19:00:36 -07001132 getWorkspace().setClipChildren(!state.hasFlag(FLAG_MULTI_PAGE));
1133
Winson Chungef528762019-09-06 12:05:52 -07001134 finishAutoCancelActionMode();
Sunny Goyal210e1742019-10-17 12:05:38 -07001135 removeActivityFlags(ACTIVITY_STATE_TRANSITION_ACTIVE);
Sunny Goyal8f965462020-04-23 19:00:36 -07001136
1137 // dispatch window state changed
1138 getWindow().getDecorView().sendAccessibilityEvent(TYPE_WINDOW_STATE_CHANGED);
1139 AccessibilityManagerCompat.sendStateEventToTest(this, state.ordinal);
1140
1141 if (state == NORMAL) {
1142 // Re-enable any Un/InstallShortcutReceiver and now process any queued items
Sunny Goyal60e68c92020-08-12 13:59:27 -07001143 ItemInstallQueue.INSTANCE.get(this)
1144 .resumeModelPush(FLAG_DRAG_AND_DROP);
Sunny Goyal8f965462020-04-23 19:00:36 -07001145
1146 // Clear any rotation locks when going to normal state
1147 getRotationHelper().setCurrentStateRequest(REQUEST_NONE);
1148 }
thiruramc96873c2021-02-11 15:13:47 -08001149
thiruramea56f842021-06-02 16:02:37 -07001150 if (ALL_APPS.equals(mPrevLauncherState) && !ALL_APPS.equals(state)
thiruram0eabc782021-04-02 14:30:10 -07001151 // Making sure mAllAppsSessionLogId is not null to avoid double logging.
thiruramc96873c2021-02-11 15:13:47 -08001152 && mAllAppsSessionLogId != null) {
Samuel Fuface820f52021-06-18 17:23:48 -05001153 getAppsView().reset(false);
Santhosh Thangaraj19292442021-06-08 20:28:24 +00001154 getStatsLogManager().logger()
1155 .withContainerInfo(LauncherAtom.ContainerInfo.newBuilder()
1156 .setWorkspace(
1157 LauncherAtom.WorkspaceContainer.newBuilder()
1158 .setPageIndex(getWorkspace().getCurrentPage()))
1159 .build())
1160 .log(LAUNCHER_ALLAPPS_EXIT);
thiruramc96873c2021-02-11 15:13:47 -08001161 mAllAppsSessionLogId = null;
1162 }
Winson Chungef528762019-09-06 12:05:52 -07001163 }
1164
Michael Jurkacd496d72013-04-11 11:32:45 -07001165 @Override
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001166 protected void onResume() {
Winson Chung5cc62c72019-10-16 11:32:41 -07001167 Object traceToken = TraceHelper.INSTANCE.beginSection(ON_RESUME_EVT,
1168 TraceHelper.FLAG_UI_EVENT);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001169 super.onResume();
Sunny Goyalfca6bc92017-09-28 16:28:34 -07001170
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001171 if (mDeferOverlayCallbacks) {
1172 scheduleDeferredCheck();
1173 } else {
1174 mOverlayManager.onActivityResumed(this);
Adam Cohen9211d422014-10-07 18:14:53 -07001175 }
Mario Bertschler0fc6f682017-02-17 12:16:13 -08001176
Winson Chung5cc62c72019-10-16 11:32:41 -07001177 TraceHelper.INSTANCE.endSection(traceToken);
Adam Cohen06dff352012-06-01 17:17:08 -07001178 }
1179
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001180 @Override
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001181 protected void onPause() {
Winson Chung997a9232013-07-24 15:33:46 -07001182 // Ensure that items added to Launcher are queued until Launcher returns
Sunny Goyal60e68c92020-08-12 13:59:27 -07001183 ItemInstallQueue.INSTANCE.get(this).pauseModelPush(FLAG_ACTIVITY_PAUSED);
Winson Chung997a9232013-07-24 15:33:46 -07001184
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001185 super.onPause();
Joe Onorato24b6fd82009-11-12 13:47:09 -08001186 mDragController.cancelDrag();
Sunny Goyal9b180102020-03-11 10:02:29 -07001187 mLastTouchUpTime = -1;
Hyunyoung Song497708c2019-05-01 16:16:53 -07001188 mDropTargetBar.animateToVisibility(false);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001189
1190 if (!mDeferOverlayCallbacks) {
1191 mOverlayManager.onActivityPaused(this);
Adam Cohenbffe7452013-07-22 18:21:45 -07001192 }
vadimt04ebcf42021-02-03 15:31:51 -08001193 mAppWidgetHost.setActivityResumed(false);
Adam Cohenbffe7452013-07-22 18:21:45 -07001194 }
1195
Lucas Dupin87d75202021-07-28 10:24:54 -07001196 /**
1197 * {@code LauncherOverlayCallbacks} scroll amount.
1198 * Indicates transition progress to -1 screen.
1199 * @param progress From 0 to 1.
1200 */
1201 @Override
1202 public void onScrollChanged(float progress) {
1203 if (mWorkspace != null) {
1204 mWorkspace.onOverlayScrollChanged(progress);
Sunny Goyalc86df472016-02-25 09:19:38 -08001205 }
Adam Cohenc2d6e892014-10-16 09:49:24 -07001206 }
1207
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001208 /**
1209 * Restores the previous state, if it exists.
1210 *
1211 * @param savedState The previous state.
1212 */
1213 private void restoreState(Bundle savedState) {
1214 if (savedState == null) {
1215 return;
1216 }
1217
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001218 int stateOrdinal = savedState.getInt(RUNTIME_STATE, NORMAL.ordinal);
Sunny Goyalf9403d92017-10-18 10:55:56 -07001219 LauncherState[] stateValues = LauncherState.values();
1220 LauncherState state = stateValues[stateOrdinal];
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08001221
1222 NonConfigInstance lastInstance = (NonConfigInstance) getLastNonConfigurationInstance();
1223 boolean forceRestore = lastInstance != null
1224 && (lastInstance.config.diff(mOldConfig) & CONFIG_UI_MODE) != 0;
1225 if (forceRestore || !state.shouldDisableRestore()) {
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001226 mStateManager.goToState(state, false /* animated */);
Joe Onorato3a8820b2009-11-10 15:06:42 -08001227 }
1228
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001229 PendingRequestArgs requestArgs = savedState.getParcelable(
1230 RUNTIME_STATE_PENDING_REQUEST_ARGS);
Sunny Goyal2100c782016-08-22 16:00:03 -07001231 if (requestArgs != null) {
1232 setWaitingForResult(requestArgs);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001233 }
Sunny Goyaldedda052019-05-14 15:23:48 -07001234 mPendingActivityRequestCode = savedState.getInt(RUNTIME_STATE_PENDING_REQUEST_CODE);
Sunny Goyal2100c782016-08-22 16:00:03 -07001235
1236 mPendingActivityResult = savedState.getParcelable(RUNTIME_STATE_PENDING_ACTIVITY_RESULT);
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001237
1238 SparseArray<Parcelable> widgetsState =
1239 savedState.getSparseParcelableArray(RUNTIME_STATE_WIDGET_PANEL);
1240 if (widgetsState != null) {
1241 WidgetsFullSheet.show(this, false).restoreHierarchyState(widgetsState);
1242 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001243 }
1244
1245 /**
1246 * Finds all the views we need and configure them properly.
1247 */
Tony Wickham04fca162020-02-05 15:06:52 -08001248 protected void setupViews() {
Sunny Goyalcc96aa12018-01-11 09:56:07 -08001249 mDragLayer = findViewById(R.id.drag_layer);
Sunny Goyal3333b0c2016-05-09 20:43:21 -07001250 mFocusHandler = mDragLayer.getFocusIndicatorHelper();
Sunny Goyal966d9012017-06-06 16:43:59 -07001251 mWorkspace = mDragLayer.findViewById(R.id.workspace);
Sunny Goyald0a6ae72016-06-16 12:29:03 -07001252 mWorkspace.initParentViews(mDragLayer);
Sreyas321bfae2020-02-21 17:53:02 -08001253 mOverviewPanel = findViewById(R.id.overview_panel);
Sunny Goyal7c7be8c2018-03-07 19:58:07 -08001254 mHotseat = findViewById(R.id.hotseat);
Adam Cohenb66675a2020-05-15 16:16:17 -07001255 mHotseat.setWorkspace(mWorkspace);
Craig Mautner360310b2012-10-26 15:13:08 -07001256
Winson Chung4c98d922011-05-31 16:50:48 -07001257 // Setup the drag layer
Sunny Goyal5d1873a2018-05-08 11:10:44 -07001258 mDragLayer.setup(mDragController, mWorkspace);
Winson Chung4c98d922011-05-31 16:50:48 -07001259
Hyunyoung Song645764e2016-06-06 14:19:02 -07001260 mWorkspace.setup(mDragController);
Winsonc7d2e832016-07-28 12:24:55 -07001261 // Until the workspace is bound, ensure that we keep the wallpaper offset locked to the
1262 // default state, otherwise we will update to the wrong offsets in RTL
1263 mWorkspace.lockWallpaperToDefaultPage();
Sunny Goyalbb030562021-07-19 16:28:39 -07001264 mWorkspace.bindAndInitFirstWorkspaceScreen();
Hyunyoung Song645764e2016-06-06 14:19:02 -07001265 mDragController.addDragListener(mWorkspace);
Winson Chung4c98d922011-05-31 16:50:48 -07001266
Tony Wickham34d2c912015-09-11 09:27:58 -07001267 // Get the search/delete/uninstall bar
Rajeev Kumar43c0f582017-06-23 15:34:55 -07001268 mDropTargetBar = mDragLayer.findViewById(R.id.drop_target_bar);
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07001269
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001270 // Setup Apps
1271 mAppsView = findViewById(R.id.apps_view);
Craig Mautner360310b2012-10-26 15:13:08 -07001272
Govinda Wassermanc06e1512019-04-09 09:56:53 -04001273 // Setup Scrim
1274 mScrimView = findViewById(R.id.scrim_view);
1275
Winson Chung3d503fb2011-07-13 17:25:49 -07001276 // Setup the drag controller (drop targets have to be added in reverse order in priority)
Sunny Goyal47328fd2016-05-25 18:56:41 -07001277 mDropTargetBar.setup(mDragController);
Samuel Fufaacebd1f2021-05-06 10:02:03 -05001278 mAllAppsController.setupViews(mScrimView, mAppsView);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001279 }
1280
1281 /**
1282 * Creates a view representing a shortcut.
1283 *
1284 * @param info The data structure describing the shortcut.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001285 */
Sunny Goyal95899162019-03-27 16:03:06 -07001286 View createShortcut(WorkspaceItemInfo info) {
Sunny Goyaldfaccf62015-05-11 16:30:44 -07001287 return createShortcut((ViewGroup) mWorkspace.getChildAt(mWorkspace.getCurrentPage()), info);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001288 }
1289
1290 /**
1291 * Creates a view representing a shortcut inflated from the specified resource.
1292 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001293 * @param parent The group the shortcut belongs to.
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001294 * @param info The data structure describing the shortcut.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001295 * @return A View inflated from layoutResId.
1296 */
Sunny Goyal95899162019-03-27 16:03:06 -07001297 public View createShortcut(ViewGroup parent, WorkspaceItemInfo info) {
Sunny Goyal9b29ca52017-02-17 10:39:44 -08001298 BubbleTextView favorite = (BubbleTextView) LayoutInflater.from(parent.getContext())
1299 .inflate(R.layout.app_icon, parent, false);
Sunny Goyal95899162019-03-27 16:03:06 -07001300 favorite.applyFromWorkspaceItem(info);
Sunny Goyal8a2a63b2018-03-06 22:15:18 -08001301 favorite.setOnClickListener(ItemClickHandler.INSTANCE);
Sunny Goyaldcbcc862014-08-12 15:58:36 -07001302 favorite.setOnFocusChangeListener(mFocusHandler);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001303 return favorite;
1304 }
1305
1306 /**
Jon Mirandac476d6e2017-05-04 16:30:01 -07001307 * Add a shortcut to the workspace or to a Folder.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001308 *
1309 * @param data The intent describing the shortcut.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001310 */
sfufa@google.comd0a33232021-09-19 15:59:36 -07001311 protected void completeAddShortcut(Intent data, int container, int screenId, int cellX,
Sunny Goyalfb5096d2016-09-08 14:32:06 -07001312 int cellY, PendingRequestArgs args) {
Pinyao Ting5eee5f42019-10-31 16:47:35 -07001313 if (args.getRequestCode() != REQUEST_CREATE_SHORTCUT
Jon Mirandac476d6e2017-05-04 16:30:01 -07001314 || args.getPendingIntent().getComponent() == null) {
Sunny Goyalfb5096d2016-09-08 14:32:06 -07001315 return;
1316 }
Adam Cohen558baaf2011-08-15 15:22:57 -07001317
Jon Mirandac476d6e2017-05-04 16:30:01 -07001318 int[] cellXY = mTmpAddItemCellCoordinates;
1319 CellLayout layout = getCellLayout(container, screenId);
1320
Sunny Goyaleaf7a952020-07-29 16:54:20 -07001321 WorkspaceItemInfo info = PinRequestHelper.createWorkspaceItemFromPinItemRequest(
Sunny Goyale7b00122019-10-02 16:13:34 -07001322 this, PinRequestHelper.getPinItemRequest(data), 0);
Sunny Goyal782f0c92017-01-19 10:27:54 -08001323
1324 if (info == null) {
Sunny Goyalb57645f2017-03-20 13:57:28 -07001325 // Legacy shortcuts are only supported for primary profile.
1326 info = Process.myUserHandle().equals(args.user)
Sunny Goyal53116c62020-08-07 16:32:18 -07001327 ? ModelUtils.fromLegacyShortcutIntent(this, data) : null;
Sunny Goyal782f0c92017-01-19 10:27:54 -08001328
Sunny Goyalb57645f2017-03-20 13:57:28 -07001329 if (info == null) {
1330 Log.e(TAG, "Unable to parse a valid custom shortcut result");
1331 return;
1332 } else if (!new PackageManagerHelper(this).hasPermissionForActivity(
Sunny Goyal342e4662017-02-02 15:21:08 -08001333 info.intent, args.getPendingIntent().getComponent().getPackageName())) {
Sunny Goyal782f0c92017-01-19 10:27:54 -08001334 // The app is trying to add a shortcut without sufficient permissions
1335 Log.e(TAG, "Ignoring malicious intent " + info.intent.toUri(0));
1336 return;
1337 }
1338 }
1339
Jon Mirandac476d6e2017-05-04 16:30:01 -07001340 if (container < 0) {
1341 // Adding a shortcut to the Workspace.
1342 final View view = createShortcut(info);
1343 boolean foundCellSpan = false;
1344 // First we check if we already know the exact location where we want to add this item.
1345 if (cellX >= 0 && cellY >= 0) {
1346 cellXY[0] = cellX;
1347 cellXY[1] = cellY;
1348 foundCellSpan = true;
Adam Cohen558baaf2011-08-15 15:22:57 -07001349
Hyunyoung Song1ae42422020-01-26 23:25:14 -08001350 DragObject dragObject = new DragObject(getApplicationContext());
1351 dragObject.dragInfo = info;
Jon Mirandac476d6e2017-05-04 16:30:01 -07001352 // If appropriate, either create a folder or add to an existing folder
1353 if (mWorkspace.createUserFolderIfNecessary(view, container, layout, cellXY, 0,
Hyunyoung Song1ae42422020-01-26 23:25:14 -08001354 true, dragObject)) {
Jon Mirandac476d6e2017-05-04 16:30:01 -07001355 return;
1356 }
Jon Mirandac476d6e2017-05-04 16:30:01 -07001357 if (mWorkspace.addToExistingFolderIfNecessary(view, layout, cellXY, 0, dragObject,
1358 true)) {
1359 return;
1360 }
1361 } else {
1362 foundCellSpan = layout.findCellForSpan(cellXY, 1, 1);
1363 }
1364
1365 if (!foundCellSpan) {
Yogisha Dixit104d09f2021-07-19 14:05:17 +01001366 mWorkspace.onNoCellFound(layout, info, /* logInstanceId= */ null);
Adam Cohen558baaf2011-08-15 15:22:57 -07001367 return;
1368 }
Jon Mirandac476d6e2017-05-04 16:30:01 -07001369
1370 getModelWriter().addItemToDatabase(info, container, screenId, cellXY[0], cellXY[1]);
1371 mWorkspace.addInScreen(view, info);
Michael Jurkad3ef3062010-11-23 16:23:58 -08001372 } else {
Jon Mirandac476d6e2017-05-04 16:30:01 -07001373 // Adding a shortcut to a Folder.
Sunny Goyale29897f52017-07-20 10:09:42 -07001374 FolderIcon folderIcon = findFolderIcon(container);
Jon Mirandac476d6e2017-05-04 16:30:01 -07001375 if (folderIcon != null) {
1376 FolderInfo folderInfo = (FolderInfo) folderIcon.getTag();
1377 folderInfo.add(info, args.rank, false);
1378 } else {
Sunny Goyale29897f52017-07-20 10:09:42 -07001379 Log.e(TAG, "Could not find folder with id " + container + " to add shortcut.");
Jon Mirandac476d6e2017-05-04 16:30:01 -07001380 }
Michael Jurka0280c3b2010-09-17 15:00:07 -07001381 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001382 }
1383
Tony Wickhamc7cbf252021-05-24 15:46:48 -07001384 @Override
1385 public @Nullable FolderIcon findFolderIcon(final int folderIconId) {
Sunny Goyal83fd25e2018-07-09 16:47:01 -07001386 return (FolderIcon) mWorkspace.getHomescreenIconByItemId(folderIconId);
Sunny Goyale29897f52017-07-20 10:09:42 -07001387 }
1388
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001389 /**
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001390 * Add a widget to the workspace.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001391 *
Romain Guy5bbc91b2010-08-18 11:38:46 -07001392 * @param appWidgetId The app widget id
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001393 */
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001394 @Thunk
1395 void completeAddAppWidget(int appWidgetId, ItemInfo itemInfo,
Adam Cohen59400422014-03-05 18:07:04 -08001396 AppWidgetHostView hostView, LauncherAppWidgetProviderInfo appWidgetInfo) {
1397
Adam Cohened66b2b2012-01-23 17:28:51 -08001398 if (appWidgetInfo == null) {
Sunny Goyal2e1efb42016-03-03 16:58:55 -08001399 appWidgetInfo = mAppWidgetManager.getLauncherAppWidgetInfo(appWidgetId);
Adam Cohened66b2b2012-01-23 17:28:51 -08001400 }
Romain Guycbb89e42009-06-08 15:52:54 -07001401
Yogisha Dixit0b15c7e2021-05-10 12:01:58 +01001402 if (hostView == null) {
1403 // Perform actual inflation because we're live
1404 hostView = mAppWidgetHost.createView(this, appWidgetId, appWidgetInfo);
1405 }
1406
Adam Cohen59400422014-03-05 18:07:04 -08001407 LauncherAppWidgetInfo launcherInfo;
Yogisha Dixit0b15c7e2021-05-10 12:01:58 +01001408 launcherInfo =
1409 new LauncherAppWidgetInfo(
1410 appWidgetId, appWidgetInfo.provider, appWidgetInfo, hostView);
Sunny Goyal2100c782016-08-22 16:00:03 -07001411 launcherInfo.spanX = itemInfo.spanX;
1412 launcherInfo.spanY = itemInfo.spanY;
1413 launcherInfo.minSpanX = itemInfo.minSpanX;
1414 launcherInfo.minSpanY = itemInfo.minSpanY;
Sunny Goyal952e63d2017-08-16 04:59:08 -07001415 launcherInfo.user = appWidgetInfo.getProfile();
Yogisha Dixit658c5da2021-05-24 23:23:15 +01001416 if (itemInfo instanceof PendingAddWidgetInfo) {
1417 launcherInfo.sourceContainer = ((PendingAddWidgetInfo) itemInfo).sourceContainer;
1418 } else if (itemInfo instanceof PendingRequestArgs) {
1419 launcherInfo.sourceContainer =
1420 ((PendingRequestArgs) itemInfo).getWidgetSourceContainer();
1421 }
Romain Guycbb89e42009-06-08 15:52:54 -07001422
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001423 getModelWriter().addItemToDatabase(launcherInfo,
Sunny Goyal2100c782016-08-22 16:00:03 -07001424 itemInfo.container, itemInfo.screenId, itemInfo.cellX, itemInfo.cellY);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001425
Sunny Goyal2100c782016-08-22 16:00:03 -07001426 hostView.setVisibility(View.VISIBLE);
Sunny Goyald5462aa2016-11-22 16:52:39 +05301427 prepareAppWidget(hostView, launcherInfo);
1428 mWorkspace.addInScreen(hostView, launcherInfo);
Pinyao Tingc9074272019-11-11 11:51:44 -08001429 announceForAccessibility(R.string.item_added_to_workspace);
Yogisha Dixit037a5362021-03-22 14:13:03 +00001430
1431 // Show the widget resize frame.
1432 if (hostView instanceof LauncherAppWidgetHostView) {
1433 final LauncherAppWidgetHostView launcherHostView = (LauncherAppWidgetHostView) hostView;
1434 CellLayout cellLayout = getCellLayout(launcherInfo.container, launcherInfo.screenId);
1435 if (mStateManager.getState() == NORMAL) {
Yogisha Dixit7b1d25b2021-10-14 13:06:40 +01001436 AppWidgetResizeFrame.showForWidget(launcherHostView, cellLayout);
Yogisha Dixit037a5362021-03-22 14:13:03 +00001437 } else {
1438 mStateManager.addStateListener(new StateManager.StateListener<LauncherState>() {
1439 @Override
1440 public void onStateTransitionComplete(LauncherState finalState) {
1441 if (mPrevLauncherState == SPRING_LOADED && finalState == NORMAL) {
1442 AppWidgetResizeFrame.showForWidget(launcherHostView, cellLayout);
1443 mStateManager.removeStateListener(this);
1444 }
1445 }
1446 });
1447 }
1448 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001449 }
Romain Guycbb89e42009-06-08 15:52:54 -07001450
Sunny Goyald5462aa2016-11-22 16:52:39 +05301451 private void prepareAppWidget(AppWidgetHostView hostView, LauncherAppWidgetInfo item) {
Sunny Goyal87af0fd2016-05-16 14:56:02 -07001452 hostView.setTag(item);
1453 item.onBindAppWidget(this, hostView);
Sunny Goyal87af0fd2016-05-16 14:56:02 -07001454 hostView.setFocusable(true);
1455 hostView.setOnFocusChangeListener(mFocusHandler);
Sunny Goyal25c2e3e2015-10-28 23:28:21 -07001456 }
1457
Sunny Goyal5d1873a2018-05-08 11:10:44 -07001458 private final BroadcastReceiver mScreenOffReceiver = new BroadcastReceiver() {
Adam Cohended9f8d2010-11-03 13:25:16 -07001459 @Override
1460 public void onReceive(Context context, Intent intent) {
Tracy Zhouf20a4bd2021-04-19 21:37:08 -07001461 onScreenOff();
Adam Cohended9f8d2010-11-03 13:25:16 -07001462 }
1463 };
1464
Sunny Goyal9c2b9602020-01-07 13:07:55 -08001465 private void updateNotificationDots(Predicate<PackageUserKey> updatedDots) {
Tony Wickhamf34bee82018-12-03 18:11:39 -08001466 mWorkspace.updateNotificationDots(updatedDots);
1467 mAppsView.getAppsStore().updateNotificationDots(updatedDots);
Tony Wickham010d2552017-01-20 08:15:28 -08001468 }
1469
Adam Cohended9f8d2010-11-03 13:25:16 -07001470 @Override
1471 public void onAttachedToWindow() {
1472 super.onAttachedToWindow();
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001473 mOverlayManager.onAttachedToWindow();
Adam Cohended9f8d2010-11-03 13:25:16 -07001474 }
1475
1476 @Override
1477 public void onDetachedFromWindow() {
1478 super.onDetachedFromWindow();
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001479 mOverlayManager.onDetachedFromWindow();
1480 closeContextMenu();
Adam Cohended9f8d2010-11-03 13:25:16 -07001481 }
1482
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -07001483 @Override
1484 public Object onRetainNonConfigurationInstance() {
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08001485 NonConfigInstance instance = new NonConfigInstance();
1486 instance.config = new Configuration(mOldConfig);
1487
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -07001488 int width = mDragLayer.getWidth();
1489 int height = mDragLayer.getHeight();
1490
Schneider Victor-tulias5aad9d82020-12-15 10:47:44 -05001491 if (FeatureFlags.ENABLE_LAUNCHER_ACTIVITY_THEME_CROSSFADE.get()
1492 && width > 0
1493 && height > 0) {
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08001494 instance.snapshot =
1495 BitmapRenderer.createHardwareBitmap(width, height, mDragLayer::draw);
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -07001496 }
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08001497 return instance;
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -07001498 }
1499
Sunny Goyalc4fa8c32017-11-07 12:23:58 -08001500 public AllAppsTransitionController getAllAppsController() {
1501 return mAllAppsController;
1502 }
1503
Sunny Goyal9d69c8d2018-03-19 13:41:31 -07001504 @Override
Winson Chunga6945242014-01-08 14:04:34 -08001505 public DragLayer getDragLayer() {
1506 return mDragLayer;
1507 }
1508
Brian Isganitis1664c9f2022-01-14 23:15:47 -05001509 @Override
1510 public ActivityAllAppsContainerView<Launcher> getAppsView() {
Winson Chungb745afb2015-03-02 11:51:23 -08001511 return mAppsView;
1512 }
1513
Winson Chunga6945242014-01-08 14:04:34 -08001514 public Workspace getWorkspace() {
1515 return mWorkspace;
1516 }
1517
1518 public Hotseat getHotseat() {
1519 return mHotseat;
1520 }
1521
Sunny Goyal7c7be8c2018-03-07 19:58:07 -08001522 public <T extends View> T getOverviewPanel() {
Winson Chung8ae41982017-11-10 11:42:13 -08001523 return (T) mOverviewPanel;
Winson Chunga6945242014-01-08 14:04:34 -08001524 }
1525
Sunny Goyal47328fd2016-05-25 18:56:41 -07001526 public DropTargetBar getDropTargetBar() {
1527 return mDropTargetBar;
Tony Wickham34d2c912015-09-11 09:27:58 -07001528 }
1529
Tony Wickhamb4821882021-04-23 14:26:45 -07001530 @Override
Tony Wickham490a8ab2020-04-01 17:03:58 -07001531 public ScrimView getScrimView() {
1532 return mScrimView;
1533 }
1534
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001535 public LauncherAppWidgetHost getAppWidgetHost() {
1536 return mAppWidgetHost;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001537 }
Romain Guycbb89e42009-06-08 15:52:54 -07001538
Cyrus Boadway0d309db2021-04-14 12:29:14 +00001539 protected LauncherAppWidgetHost createAppWidgetHost() {
1540 return new LauncherAppWidgetHost(this,
1541 appWidgetId -> getWorkspace().removeWidget(appWidgetId));
1542 }
1543
Winson Chunga9abd0e2010-10-27 17:18:37 -07001544 public LauncherModel getModel() {
1545 return mModel;
1546 }
1547
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001548 public ModelWriter getModelWriter() {
1549 return mModelWriter;
1550 }
1551
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001552 @Override
Adam Cohen79d90c52016-04-22 13:29:20 -07001553 public SharedPreferences getSharedPrefs() {
Winson Chunga6945242014-01-08 14:04:34 -08001554 return mSharedPrefs;
1555 }
1556
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001557 @Override
1558 public SharedPreferences getDevicePrefs() {
1559 return Utilities.getDevicePrefs(this);
1560 }
1561
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001562 public int getOrientation() {
1563 return mOldConfig.orientation;
1564 }
Jon Miranda6bed3502017-09-19 14:43:17 -07001565
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001566 @Override
1567 protected void onNewIntent(Intent intent) {
vadimtbaf5fbb2019-12-16 18:56:09 -08001568 if (Utilities.IS_RUNNING_IN_TEST_HARNESS) {
1569 Log.d(TestProtocol.PERMANENT_DIAG_TAG, "Launcher.onNewIntent: " + intent);
1570 }
Winson Chung5cc62c72019-10-16 11:32:41 -07001571 Object traceToken = TraceHelper.INSTANCE.beginSection(ON_NEW_INTENT_EVT);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001572 super.onNewIntent(intent);
1573
Sunny Goyalf4aceab2017-12-06 16:16:31 -08001574 boolean alreadyOnHome = hasWindowFocus() && ((intent.getFlags() &
Winson15f8b172015-08-19 11:02:39 -07001575 Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT)
1576 != Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT);
Sunny Goyal85313732016-09-28 12:00:07 -07001577
1578 // Check this condition before handling isActionMain, as this will get reset.
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001579 boolean shouldMoveToDefaultScreen = alreadyOnHome && isInState(NORMAL)
Sunny Goyalf9403d92017-10-18 10:55:56 -07001580 && AbstractFloatingView.getTopOpenView(this) == null;
Winson15f8b172015-08-19 11:02:39 -07001581 boolean isActionMain = Intent.ACTION_MAIN.equals(intent.getAction());
Winson Chung1c2d5222021-06-08 11:50:13 -07001582 boolean internalStateHandled = ACTIVITY_TRACKER.handleNewIntent(this);
Hyunyoung Song5ee7c132021-05-11 13:52:36 -07001583 hideKeyboard();
kholoud mohamedceec31b2022-02-03 15:44:25 +00001584
Winson15f8b172015-08-19 11:02:39 -07001585 if (isActionMain) {
Sunny Goyald3864fa2017-11-14 15:06:36 -08001586 if (!internalStateHandled) {
Sunny Goyald3864fa2017-11-14 15:06:36 -08001587 // In all these cases, only animate if we're already on home
Andy Wickham65ced1b2020-03-07 02:14:19 +00001588 closeOpenViews(isStarted());
Jon Mirandafeba90f2016-10-06 10:53:29 -07001589
Sunny Goyala2467272018-03-16 14:53:05 -07001590 if (!isInState(NORMAL)) {
1591 // Only change state, if not already the same. This prevents cancelling any
1592 // animations running as part of resume
Sunny Goyalfee1b252020-12-14 12:30:38 -08001593 mStateManager.goToState(NORMAL, mStateManager.shouldAnimateStateChange());
Sunny Goyala2467272018-03-16 14:53:05 -07001594 }
Sunny Goyald3864fa2017-11-14 15:06:36 -08001595
1596 // Reset the apps view
Sunny Goyal5d1873a2018-05-08 11:10:44 -07001597 if (!alreadyOnHome) {
Sunny Goyal7185dd62018-03-14 17:51:49 -07001598 mAppsView.reset(isStarted() /* animate */);
Sunny Goyald3864fa2017-11-14 15:06:36 -08001599 }
1600
Sunny Goyalaad33592018-08-07 17:20:35 -07001601 if (shouldMoveToDefaultScreen && !mWorkspace.isHandlingTouch()) {
Sunny Goyald3864fa2017-11-14 15:06:36 -08001602 mWorkspace.post(mWorkspace::moveToDefaultScreen);
1603 }
1604 }
Adam Cohen6fecd412013-10-02 17:41:50 -07001605
Adam Cohen9211d422014-10-07 18:14:53 -07001606 if (mLauncherCallbacks != null) {
Sunny Goyal85462132018-04-24 11:39:37 -07001607 mLauncherCallbacks.onHomeIntent(internalStateHandled);
Adam Cohen9211d422014-10-07 18:14:53 -07001608 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001609 mOverlayManager.hideOverlay(isStarted() && !isForceInvisible());
Sunny Goyal30ac97d2020-06-24 23:47:46 -07001610 handleGestureContract(intent);
Sunny Goyal512a2c12020-04-08 12:52:45 -07001611 } else if (Intent.ACTION_ALL_APPS.equals(intent.getAction())) {
Winson Chungdd15ace2020-08-04 15:52:01 -07001612 showAllAppsFromIntent(alreadyOnHome);
kholoud mohamedceec31b2022-02-03 15:44:25 +00001613 } else if (Intent.ACTION_SHOW_WORK_APPS.equals(intent.getAction())) {
1614 showAllAppsWorkTabFromIntent(alreadyOnHome);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001615 }
Winson15f8b172015-08-19 11:02:39 -07001616
Winson Chung5cc62c72019-10-16 11:32:41 -07001617 TraceHelper.INSTANCE.endSection(traceToken);
Adam Coppa120b8e2013-11-12 16:26:04 +00001618 }
1619
Winson Chungdd15ace2020-08-04 15:52:01 -07001620 protected void showAllAppsFromIntent(boolean alreadyOnHome) {
1621 AbstractFloatingView.closeAllOpenViews(this);
1622 getStateManager().goToState(ALL_APPS, alreadyOnHome);
1623 }
1624
kholoud mohamedceec31b2022-02-03 15:44:25 +00001625 private void showAllAppsWorkTabFromIntent(boolean alreadyOnHome) {
1626 showAllAppsFromIntent(alreadyOnHome);
1627 mAppsView.switchToTab(BaseAllAppsContainerView.AdapterHolder.WORK);
1628 }
1629
Sunny Goyaldeb91c42020-03-24 02:17:59 -07001630 /**
Sunny Goyal30ac97d2020-06-24 23:47:46 -07001631 * Handles gesture nav contract
1632 */
1633 protected void handleGestureContract(Intent intent) {
1634 GestureNavContract gnc = GestureNavContract.fromIntent(intent);
1635 if (gnc != null) {
1636 AbstractFloatingView.closeOpenViews(this, false, TYPE_ICON_SURFACE);
1637 FloatingSurfaceView.show(this, gnc);
1638 }
1639 }
1640
1641 /**
Sunny Goyaldeb91c42020-03-24 02:17:59 -07001642 * Hides the keyboard if visible
1643 */
1644 public void hideKeyboard() {
1645 final View v = getWindow().peekDecorView();
1646 if (v != null && v.getWindowToken() != null) {
1647 UiThreadHelper.hideKeyboardAsync(this, v.getWindowToken());
1648 }
1649 }
1650
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001651 @Override
Adam Cohen1462de32012-07-24 22:34:36 -07001652 public void onRestoreInstanceState(Bundle state) {
1653 super.onRestoreInstanceState(state);
Andras Kloczl55edfe52021-05-14 12:21:30 +02001654 if (mSynchronouslyBoundPages != null) {
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07001655 mSynchronouslyBoundPages.forEach(screenId -> {
1656 int pageIndex = mWorkspace.getPageIndexForScreenId(screenId);
1657 if (pageIndex != PagedView.INVALID_PAGE) {
1658 mWorkspace.restoreInstanceStateForChild(pageIndex);
1659 }
1660 });
Andras Kloczl55edfe52021-05-14 12:21:30 +02001661 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001662 }
1663
1664 @Override
1665 protected void onSaveInstanceState(Bundle outState) {
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07001666 outState.putIntArray(RUNTIME_STATE_CURRENT_SCREEN_IDS,
1667 mWorkspace.getCurrentPageScreenIds().getArray().toArray());
Sunny Goyalea609262017-10-25 15:47:38 -07001668 outState.putInt(RUNTIME_STATE, mStateManager.getState().ordinal);
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001669
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001670 AbstractFloatingView widgets = AbstractFloatingView
1671 .getOpenView(this, AbstractFloatingView.TYPE_WIDGETS_FULL_SHEET);
1672 if (widgets != null) {
1673 SparseArray<Parcelable> widgetsState = new SparseArray<>();
1674 widgets.saveHierarchyState(widgetsState);
1675 outState.putSparseParcelableArray(RUNTIME_STATE_WIDGET_PANEL, widgetsState);
1676 } else {
1677 outState.remove(RUNTIME_STATE_WIDGET_PANEL);
1678 }
1679
Pinyao Tinga74b63a2019-07-17 23:26:06 -07001680 // We close any open folders and shortcut containers that are not safe for rebind,
Sunny Goyal740ac7f2016-09-28 16:47:32 -07001681 // and we need to make sure this state is reflected.
Pinyao Tinga74b63a2019-07-17 23:26:06 -07001682 AbstractFloatingView.closeOpenViews(this, false, TYPE_ALL & ~TYPE_REBIND_SAFE);
1683 finishAutoCancelActionMode();
Tony Wickham49c8d292016-07-01 11:44:34 -07001684
Jon Miranda14d67712021-12-08 17:47:33 -08001685 DragView.removeAllViews(this);
1686
Sunny Goyal2100c782016-08-22 16:00:03 -07001687 if (mPendingRequestArgs != null) {
1688 outState.putParcelable(RUNTIME_STATE_PENDING_REQUEST_ARGS, mPendingRequestArgs);
1689 }
Sunny Goyaldedda052019-05-14 15:23:48 -07001690 outState.putInt(RUNTIME_STATE_PENDING_REQUEST_CODE, mPendingActivityRequestCode);
1691
Sunny Goyal2100c782016-08-22 16:00:03 -07001692 if (mPendingActivityResult != null) {
1693 outState.putParcelable(RUNTIME_STATE_PENDING_ACTIVITY_RESULT, mPendingActivityResult);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001694 }
1695
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07001696 super.onSaveInstanceState(outState);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001697 mOverlayManager.onActivitySaveInstanceState(this, outState);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001698 }
1699
1700 @Override
1701 public void onDestroy() {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001702 super.onDestroy();
Sunny Goyale84c5b82019-09-26 17:05:31 -07001703 ACTIVITY_TRACKER.onActivityDestroyed(this);
Romain Guycbb89e42009-06-08 15:52:54 -07001704
Sunny Goyal5d1873a2018-05-08 11:10:44 -07001705 unregisterReceiver(mScreenOffReceiver);
Sunny Goyalaaf7d1d2016-05-17 13:38:54 -07001706 mWorkspace.removeFolderListeners();
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001707 PluginManagerWrapper.INSTANCE.get(this).removePluginListener(this);
Winson Chunge7a03942011-08-05 15:05:12 -07001708
Sunny Goyala7a5bf32020-01-05 15:35:29 +05301709 mModel.removeCallbacks(this);
Sunny Goyal623eddd2018-03-02 12:24:41 -08001710 mRotationHelper.destroy();
Sunny Goyal745bad92016-05-02 10:54:12 -07001711
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001712 try {
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001713 mAppWidgetHost.stopListening();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001714 } catch (NullPointerException ex) {
Joe Onoratoa30ce8e2009-11-11 08:16:49 -08001715 Log.w(TAG, "problem while stopping AppWidgetHost during Launcher destruction", ex);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001716 }
Patrick Dubroy2313eff2011-01-11 20:01:31 -08001717
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001718 TextKeyListener.getInstance().release();
Tony2917a8b2017-07-31 23:29:42 -07001719 clearPendingBinds();
Hyunyoung Song31971a32019-01-27 12:31:12 -08001720 LauncherAppState.getIDP(this).removeOnChangeListener(this);
Sunny Goyalb1d7de22019-09-06 10:36:54 -07001721
1722 mOverlayManager.onActivityDestroyed(this);
Samuel Fufa41d909f2020-03-20 16:27:09 -07001723 mUserChangedCallbackCloseable.close();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001724 }
1725
Sunny Goyalae502842016-06-17 08:43:56 -07001726 public LauncherAccessibilityDelegate getAccessibilityDelegate() {
1727 return mAccessibilityDelegate;
1728 }
1729
Adam Cohena9cf38f2011-05-02 15:36:58 -07001730 public DragController getDragController() {
1731 return mDragController;
1732 }
1733
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001734 @Override
Sunny Goyal0eca4e22016-07-20 11:43:06 -07001735 public void startActivityForResult(Intent intent, int requestCode, Bundle options) {
Sunny Goyaldedda052019-05-14 15:23:48 -07001736 if (requestCode != -1) {
1737 mPendingActivityRequestCode = requestCode;
1738 }
Sunny Goyal210e1742019-10-17 12:05:38 -07001739 super.startActivityForResult(intent, requestCode, options);
Adam Cohen173f7112015-03-27 15:14:00 -07001740 }
1741
1742 @Override
Sunny Goyaldedda052019-05-14 15:23:48 -07001743 public void startIntentSenderForResult(IntentSender intent, int requestCode,
Adam Cohen173f7112015-03-27 15:14:00 -07001744 Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags, Bundle options) {
Sunny Goyaldedda052019-05-14 15:23:48 -07001745 if (requestCode != -1) {
1746 mPendingActivityRequestCode = requestCode;
1747 }
Sunny Goyal210e1742019-10-17 12:05:38 -07001748 try {
1749 super.startIntentSenderForResult(intent, requestCode,
1750 fillInIntent, flagsMask, flagsValues, extraFlags, options);
1751 } catch (IntentSender.SendIntentException e) {
1752 throw new ActivityNotFoundException();
Adam Cohen173f7112015-03-27 15:14:00 -07001753 }
1754 }
1755
Winson Chung70d72102011-08-12 11:24:35 -07001756 /**
1757 * Indicates that we want global search for this activity by setting the globalSearch
1758 * argument for {@link #startSearch} to true.
1759 */
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001760 @Override
Romain Guycbb89e42009-06-08 15:52:54 -07001761 public void startSearch(String initialQuery, boolean selectInitialQuery,
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001762 Bundle appSearchData, boolean globalSearch) {
1763 if (appSearchData == null) {
1764 appSearchData = new Bundle();
Bjorn Bringert32b12d22013-06-06 13:00:41 +01001765 appSearchData.putString("source", "launcher-search");
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001766 }
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07001767
Sunny Goyal6f28e712016-09-13 14:19:29 -07001768 if (mLauncherCallbacks == null ||
1769 !mLauncherCallbacks.startSearch(initialQuery, selectInitialQuery, appSearchData)) {
1770 // Starting search from the callbacks failed. Start the default global search.
Sunny Goyalf4aceab2017-12-06 16:16:31 -08001771 super.startSearch(initialQuery, selectInitialQuery, appSearchData, true);
Ian Parkinson047036e2014-09-01 15:40:53 +01001772 }
Winson Chungcd99cd32015-04-29 11:03:24 -07001773
1774 // We need to show the workspace after starting the search
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001775 mStateManager.goToState(NORMAL);
Bjorn Bringertc459e522013-06-07 19:36:01 +01001776 }
1777
Joe Onorato9c1289c2009-08-17 11:03:03 -04001778 public boolean isWorkspaceLocked() {
Sunny Goyal2100c782016-08-22 16:00:03 -07001779 return mWorkspaceLoading || mPendingRequestArgs != null;
Joe Onorato9c1289c2009-08-17 11:03:03 -04001780 }
1781
Adam Cohen517a7f52014-03-01 12:12:59 -08001782 public boolean isWorkspaceLoading() {
1783 return mWorkspaceLoading;
1784 }
1785
Brian Isganitis099945b2022-01-31 18:15:00 -05001786 @Override
1787 public boolean isBindingItems() {
1788 return mWorkspaceLoading;
1789 }
1790
Anjali Koppalff7ceff2014-05-01 18:26:37 -07001791 private void setWorkspaceLoading(boolean value) {
Anjali Koppalff7ceff2014-05-01 18:26:37 -07001792 mWorkspaceLoading = value;
Anjali Koppalff7ceff2014-05-01 18:26:37 -07001793 }
1794
Sunny Goyal04a324a2017-01-20 21:08:59 -08001795 public void setWaitingForResult(PendingRequestArgs args) {
Sunny Goyal2100c782016-08-22 16:00:03 -07001796 mPendingRequestArgs = args;
Adam Cohen9211d422014-10-07 18:14:53 -07001797 }
Anjali Koppalff7ceff2014-05-01 18:26:37 -07001798
Sunny Goyal2100c782016-08-22 16:00:03 -07001799 void addAppWidgetFromDropImpl(int appWidgetId, ItemInfo info, AppWidgetHostView boundWidget,
Sunny Goyal04a324a2017-01-20 21:08:59 -08001800 WidgetAddFlowHandler addFlowHandler) {
Tony Wickhama0628cc2015-10-14 15:23:04 -07001801 if (LOGD) {
1802 Log.d(TAG, "Adding widget from drop");
1803 }
Sunny Goyal04a324a2017-01-20 21:08:59 -08001804 addAppWidgetImpl(appWidgetId, info, boundWidget, addFlowHandler, 0);
Adam Cohenad4e15c2013-10-17 16:21:35 -07001805 }
1806
Sunny Goyal2100c782016-08-22 16:00:03 -07001807 void addAppWidgetImpl(int appWidgetId, ItemInfo info,
Sunny Goyal04a324a2017-01-20 21:08:59 -08001808 AppWidgetHostView boundWidget, WidgetAddFlowHandler addFlowHandler, int delay) {
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001809 if (!addFlowHandler.startConfigActivity(this, appWidgetId, info,
1810 REQUEST_CREATE_APPWIDGET)) {
Sunny Goyal04a324a2017-01-20 21:08:59 -08001811 // If the configuration flow was not started, add the widget
Michael Jurkaaf442092010-06-10 17:01:57 -07001812
Adam Cohenad4e15c2013-10-17 16:21:35 -07001813 Runnable onComplete = new Runnable() {
1814 @Override
1815 public void run() {
1816 // Exit spring loaded mode if necessary after adding the widget
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07001817 mStateManager.goToState(NORMAL, SPRING_LOADED_EXIT_DELAY);
Adam Cohenad4e15c2013-10-17 16:21:35 -07001818 }
1819 };
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001820 completeAddAppWidget(appWidgetId, info, boundWidget,
1821 addFlowHandler.getProviderInfo(this));
Sunny Goyal6e379fc2020-03-19 16:08:14 -07001822 mWorkspace.removeExtraEmptyScreenDelayed(delay, false, onComplete);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001823 }
1824 }
Romain Guycbb89e42009-06-08 15:52:54 -07001825
Sunny Goyalefb7e842018-10-04 15:11:00 -07001826 public void addPendingItem(PendingAddItemInfo info, int container, int screenId,
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08001827 int[] cell, int spanX, int spanY) {
Sunny Goyal2100c782016-08-22 16:00:03 -07001828 info.container = container;
1829 info.screenId = screenId;
1830 if (cell != null) {
1831 info.cellX = cell[0];
1832 info.cellY = cell[1];
1833 }
1834 info.spanX = spanX;
1835 info.spanY = spanY;
1836
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08001837 switch (info.itemType) {
1838 case LauncherSettings.Favorites.ITEM_TYPE_CUSTOM_APPWIDGET:
1839 case LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET:
Sunny Goyal2100c782016-08-22 16:00:03 -07001840 addAppWidgetFromDrop((PendingAddWidgetInfo) info);
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08001841 break;
1842 case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT:
Sunny Goyal782f0c92017-01-19 10:27:54 -08001843 processShortcutFromDrop((PendingAddShortcutInfo) info);
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08001844 break;
1845 default:
1846 throw new IllegalStateException("Unknown item type: " + info.itemType);
Samuel Fufaca37b8a2019-08-19 17:04:36 -07001847 }
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08001848 }
1849
Adam Cohenfbba09b2011-07-18 21:43:05 -07001850 /**
1851 * Process a shortcut drop.
Adam Cohenfbba09b2011-07-18 21:43:05 -07001852 */
Sunny Goyal782f0c92017-01-19 10:27:54 -08001853 private void processShortcutFromDrop(PendingAddShortcutInfo info) {
Sunny Goyalfb5096d2016-09-08 14:32:06 -07001854 Intent intent = new Intent(Intent.ACTION_CREATE_SHORTCUT).setComponent(info.componentName);
1855 setWaitingForResult(PendingRequestArgs.forIntent(REQUEST_CREATE_SHORTCUT, intent, info));
vadimtcf275c12020-04-15 12:43:01 -07001856 TestLogging.recordEvent(TestProtocol.SEQUENCE_MAIN, "start: processShortcutFromDrop");
Sunny Goyal782f0c92017-01-19 10:27:54 -08001857 if (!info.activityInfo.startConfigActivity(this, REQUEST_CREATE_SHORTCUT)) {
1858 handleActivityResult(REQUEST_CREATE_SHORTCUT, RESULT_CANCELED, null);
1859 }
Michael Jurka0280c3b2010-09-17 15:00:07 -07001860 }
1861
Adam Cohenfbba09b2011-07-18 21:43:05 -07001862 /**
1863 * Process a widget drop.
Adam Cohenfbba09b2011-07-18 21:43:05 -07001864 */
Sunny Goyal2100c782016-08-22 16:00:03 -07001865 private void addAppWidgetFromDrop(PendingAddWidgetInfo info) {
Adam Cohened66b2b2012-01-23 17:28:51 -08001866 AppWidgetHostView hostView = info.boundWidget;
Sunny Goyal952e63d2017-08-16 04:59:08 -07001867 final int appWidgetId;
Sunny Goyal8a0dc382017-01-25 11:30:06 -08001868 WidgetAddFlowHandler addFlowHandler = info.getHandler();
Adam Cohened66b2b2012-01-23 17:28:51 -08001869 if (hostView != null) {
Tony Wickhama0628cc2015-10-14 15:23:04 -07001870 // In the case where we've prebound the widget, we remove it from the DragLayer
1871 if (LOGD) {
1872 Log.d(TAG, "Removing widget view from drag layer and setting boundWidget to null");
1873 }
1874 getDragLayer().removeView(hostView);
1875
Adam Cohened66b2b2012-01-23 17:28:51 -08001876 appWidgetId = hostView.getAppWidgetId();
Sunny Goyal04a324a2017-01-20 21:08:59 -08001877 addAppWidgetFromDropImpl(appWidgetId, info, hostView, addFlowHandler);
Sunny Goyal5b9ebca2015-06-01 18:37:32 -07001878
1879 // Clear the boundWidget so that it doesn't get destroyed.
1880 info.boundWidget = null;
Adam Cohened66b2b2012-01-23 17:28:51 -08001881 } else {
Adam Cohen9d5b7d82012-05-09 18:00:44 -07001882 // In this case, we either need to start an activity to get permission to bind
1883 // the widget, or we need to start an activity to configure the widget, or both.
Pinyao Tingc7a6c292019-08-26 14:36:02 -07001884 if (info.itemType == LauncherSettings.Favorites.ITEM_TYPE_CUSTOM_APPWIDGET) {
1885 appWidgetId = CustomWidgetManager.INSTANCE.get(this).getWidgetIdForCustomProvider(
1886 info.componentName);
Sunny Goyal952e63d2017-08-16 04:59:08 -07001887 } else {
1888 appWidgetId = getAppWidgetHost().allocateAppWidgetId();
1889 }
Adam Cohendd70d662012-10-04 16:53:44 -07001890 Bundle options = info.bindOptions;
1891
Sunny Goyalffe83f12014-08-14 17:39:34 -07001892 boolean success = mAppWidgetManager.bindAppWidgetIdIfAllowed(
1893 appWidgetId, info.info, options);
Adam Cohendd70d662012-10-04 16:53:44 -07001894 if (success) {
Sunny Goyal04a324a2017-01-20 21:08:59 -08001895 addAppWidgetFromDropImpl(appWidgetId, info, null, addFlowHandler);
Michael Jurka8b805b12012-04-18 14:23:14 -07001896 } else {
Sunny Goyal04a324a2017-01-20 21:08:59 -08001897 addFlowHandler.startBindFlow(this, appWidgetId, info, REQUEST_BIND_APPWIDGET);
Michael Jurka8b805b12012-04-18 14:23:14 -07001898 }
Adam Cohened66b2b2012-01-23 17:28:51 -08001899 }
Adam Cohenfbba09b2011-07-18 21:43:05 -07001900 }
1901
Samuel Fufa746d4202020-02-02 18:55:44 -08001902 /**
1903 * Creates and adds new folder to CellLayout
1904 */
Samuel Fufa28c3e452020-02-08 16:07:16 -08001905 public FolderIcon addFolder(CellLayout layout, int container, final int screenId, int cellX,
1906 int cellY) {
Michael Jurkac9d95c52011-08-29 14:03:34 -07001907 final FolderInfo folderInfo = new FolderInfo();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001908
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001909 // Update the model
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001910 getModelWriter().addItemToDatabase(folderInfo, container, screenId, cellX, cellY);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001911
1912 // Create the view
Samuel Fufa746d4202020-02-02 18:55:44 -08001913 FolderIcon newFolder = FolderIcon.inflateFolderAndIcon(R.layout.folder_icon, this, layout,
1914 folderInfo);
Sunny Goyald5462aa2016-11-22 16:52:39 +05301915 mWorkspace.addInScreen(newFolder, folderInfo);
Winson Chung5f8afe62013-08-12 16:19:28 -07001916 // Force measure the new folder icon
1917 CellLayout parent = mWorkspace.getParentCellLayoutForView(newFolder);
1918 parent.getShortcutsAndWidgets().measureChild(newFolder);
Adam Cohendf035382011-04-11 17:22:04 -07001919 return newFolder;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001920 }
Romain Guycbb89e42009-06-08 15:52:54 -07001921
Tony Wickham1906cc32021-02-11 11:55:24 -08001922 @Override
1923 public Rect getFolderBoundingBox() {
1924 // We need to bound the folder to the currently visible workspace area
Andras Kloczl3a4ba0b2021-03-29 18:47:14 +02001925 return getWorkspace().getPageAreaRelativeToDragLayer();
Tony Wickham1906cc32021-02-11 11:55:24 -08001926 }
1927
1928 @Override
1929 public void updateOpenFolderPosition(int[] inOutPosition, Rect bounds, int width, int height) {
1930 int left = inOutPosition[0];
1931 int top = inOutPosition[1];
1932 DeviceProfile grid = getDeviceProfile();
1933 int distFromEdgeOfScreen = getWorkspace().getPaddingLeft();
1934 if (grid.isPhone && (grid.availableWidthPx - width) < 4 * distFromEdgeOfScreen) {
1935 // Center the folder if it is very close to being centered anyway, by virtue of
1936 // filling the majority of the viewport. ie. remove it from the uncanny valley
1937 // of centeredness.
1938 left = (grid.availableWidthPx - width) / 2;
1939 } else if (width >= bounds.width()) {
1940 // If the folder doesn't fit within the bounds, center it about the desired bounds
1941 left = bounds.left + (bounds.width() - width) / 2;
1942 }
1943 if (height >= bounds.height()) {
1944 // Folder height is greater than page height, center on page
1945 top = bounds.top + (bounds.height() - height) / 2;
1946 } else {
1947 // Folder height is less than page height, so bound it to the absolute open folder
1948 // bounds if necessary
1949 Rect folderBounds = grid.getAbsoluteOpenFolderBounds();
1950 left = Math.max(folderBounds.left, Math.min(left, folderBounds.right - width));
1951 top = Math.max(folderBounds.top, Math.min(top, folderBounds.bottom - height));
1952 }
1953 inOutPosition[0] = left;
1954 inOutPosition[1] = top;
1955 }
1956
Winsonc0b52fe2015-09-09 16:38:15 -07001957 /**
Winsonfa56b3f2015-09-14 12:01:13 -07001958 * Unbinds the view for the specified item, and removes the item and all its children.
1959 *
1960 * @param v the view being removed.
Winsonfa56b3f2015-09-14 12:01:13 -07001961 * @param itemInfo the {@link ItemInfo} for this view.
1962 * @param deleteFromDb whether or not to delete this item from the db.
Winsonc0b52fe2015-09-09 16:38:15 -07001963 */
Tony Wickhambfbf7f92016-05-19 11:19:39 -07001964 public boolean removeItem(View v, final ItemInfo itemInfo, boolean deleteFromDb) {
Sunny Goyal95899162019-03-27 16:03:06 -07001965 if (itemInfo instanceof WorkspaceItemInfo) {
Winsonfa56b3f2015-09-14 12:01:13 -07001966 // Remove the shortcut from the folder before removing it from launcher
Sunny Goyal44c06432016-04-02 10:56:02 -07001967 View folderIcon = mWorkspace.getHomescreenIconByItemId(itemInfo.container);
1968 if (folderIcon instanceof FolderIcon) {
Sunny Goyal95899162019-03-27 16:03:06 -07001969 ((FolderInfo) folderIcon.getTag()).remove((WorkspaceItemInfo) itemInfo, true);
Winsonfa56b3f2015-09-14 12:01:13 -07001970 } else {
1971 mWorkspace.removeWorkspaceItem(v);
1972 }
Winsonc0b52fe2015-09-09 16:38:15 -07001973 if (deleteFromDb) {
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001974 getModelWriter().deleteItemFromDatabase(itemInfo);
Winsonc0b52fe2015-09-09 16:38:15 -07001975 }
1976 } else if (itemInfo instanceof FolderInfo) {
1977 final FolderInfo folderInfo = (FolderInfo) itemInfo;
Sunny Goyalaaf7d1d2016-05-17 13:38:54 -07001978 if (v instanceof FolderIcon) {
1979 ((FolderIcon) v).removeListeners();
1980 }
Winsonc0b52fe2015-09-09 16:38:15 -07001981 mWorkspace.removeWorkspaceItem(v);
1982 if (deleteFromDb) {
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001983 getModelWriter().deleteFolderAndContentsFromDatabase(folderInfo);
Winsonc0b52fe2015-09-09 16:38:15 -07001984 }
1985 } else if (itemInfo instanceof LauncherAppWidgetInfo) {
1986 final LauncherAppWidgetInfo widgetInfo = (LauncherAppWidgetInfo) itemInfo;
Winson44818e02015-10-02 11:25:46 -07001987 mWorkspace.removeWorkspaceItem(v);
Winsonc0b52fe2015-09-09 16:38:15 -07001988 if (deleteFromDb) {
Tony Wickham6a71a5b2018-08-21 11:40:23 -07001989 getModelWriter().deleteWidgetInfo(widgetInfo, getAppWidgetHost());
Winsonc0b52fe2015-09-09 16:38:15 -07001990 }
1991 } else {
1992 return false;
1993 }
1994 return true;
1995 }
1996
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001997 @Override
1998 public boolean dispatchKeyEvent(KeyEvent event) {
vadimt6b534ee2021-08-06 15:49:02 -07001999 TestLogging.recordKeyEvent(TestProtocol.SEQUENCE_MAIN, "Key event", event);
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08002000 return (event.getKeyCode() == KeyEvent.KEYCODE_HOME) || super.dispatchKeyEvent(event);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002001 }
2002
Joe Onorato88ec0992009-11-19 13:16:06 -08002003 @Override
vadimt9af34a72020-01-21 11:19:13 -08002004 public boolean dispatchTouchEvent(MotionEvent ev) {
Sunny Goyala306e592020-03-24 01:51:41 -07002005 switch (ev.getAction()) {
2006 case MotionEvent.ACTION_DOWN:
2007 mTouchInProgress = true;
2008 break;
2009 case MotionEvent.ACTION_UP:
Riddle Hsub30adcb2020-10-07 15:57:44 +08002010 mLastTouchUpTime = SystemClock.uptimeMillis();
Sunny Goyala306e592020-03-24 01:51:41 -07002011 // Follow through
2012 case MotionEvent.ACTION_CANCEL:
2013 mTouchInProgress = false;
2014 break;
Sunny Goyal9b180102020-03-11 10:02:29 -07002015 }
vadimtd633c9c2020-01-22 18:00:37 -08002016 TestLogging.recordMotionEvent(TestProtocol.SEQUENCE_MAIN, "Touch event", ev);
vadimt9af34a72020-01-21 11:19:13 -08002017 return super.dispatchTouchEvent(ev);
2018 }
2019
Sunny Goyala306e592020-03-24 01:51:41 -07002020 /**
2021 * Returns true if a touch interaction is in progress
2022 */
2023 public boolean isTouchInProgress() {
2024 return mTouchInProgress;
2025 }
2026
vadimt9af34a72020-01-21 11:19:13 -08002027 @Override
Joe Onorato88ec0992009-11-19 13:16:06 -08002028 public void onBackPressed() {
Sunny Goyal7c8a65e2017-12-22 11:11:33 -08002029 if (finishAutoCancelActionMode()) {
2030 return;
2031 }
Adam Cohen9211d422014-10-07 18:14:53 -07002032
Sunny Goyal45478022015-06-08 16:52:41 -07002033 if (mDragController.isDragging()) {
2034 mDragController.cancelDrag();
Adam Cohenc9735cf2015-01-23 16:11:55 -08002035 return;
2036 }
2037
Jon Mirandafeba90f2016-10-06 10:53:29 -07002038 // Note: There should be at most one log per method call. This is enforced implicitly
2039 // by using if-else statements.
Sunny Goyal740ac7f2016-09-28 16:47:32 -07002040 AbstractFloatingView topView = AbstractFloatingView.getTopOpenView(this);
Tony Wickham52c1b662018-05-21 13:13:58 -07002041 if (topView != null && topView.onBackPressed()) {
2042 // Handled by the floating view.
Patrick Dubroy94f78a52011-02-28 17:39:16 -08002043 } else {
Sunny Goyale39690b2018-08-02 13:35:07 -07002044 mStateManager.getState().onBackPressed(this);
Michael Jurkaaf442092010-06-10 17:01:57 -07002045 }
Joe Onorato88ec0992009-11-19 13:16:06 -08002046 }
2047
Tracy Zhouf20a4bd2021-04-19 21:37:08 -07002048 protected void onScreenOff() {
2049 // Reset AllApps to its initial state only if we are not in the middle of
2050 // processing a multi-step drop
2051 if (mPendingRequestArgs == null) {
2052 if (!isInState(NORMAL)) {
2053 onUiChangedWhileSleeping();
2054 }
2055 mStateManager.goToState(NORMAL);
2056 }
2057 }
2058
Sunny Goyalfe770c92016-09-27 14:38:58 -07002059 @TargetApi(Build.VERSION_CODES.M)
Sunny Goyal0b0847b2018-03-14 12:30:11 -07002060 @Override
Sunny Goyal0b0847b2018-03-14 12:30:11 -07002061 protected boolean onErrorStartingShortcut(Intent intent, ItemInfo info) {
2062 // Due to legacy reasons, direct call shortcuts require Launchers to have the
2063 // corresponding permission. Show the appropriate permission prompt if that
2064 // is the case.
2065 if (intent.getComponent() == null
2066 && Intent.ACTION_CALL.equals(intent.getAction())
2067 && checkSelfPermission(android.Manifest.permission.CALL_PHONE) !=
2068 PackageManager.PERMISSION_GRANTED) {
2069
2070 setWaitingForResult(PendingRequestArgs
2071 .forIntent(REQUEST_PERMISSION_CALL_PHONE, intent, info));
2072 requestPermissions(new String[]{android.Manifest.permission.CALL_PHONE},
2073 REQUEST_PERMISSION_CALL_PHONE);
2074 return true;
2075 } else {
2076 return false;
2077 }
Sunny Goyal0eca4e22016-07-20 11:43:06 -07002078 }
2079
Hyunyoung Song46d07f72018-05-22 15:41:25 -07002080 @Override
Sunny Goyal852537f2020-07-15 17:02:16 -07002081 public boolean startActivitySafely(View v, Intent intent, ItemInfo item) {
Winson Chung0b70cd42019-06-17 22:34:33 -07002082 if (!hasBeenResumed()) {
2083 // Workaround an issue where the WM launch animation is clobbered when finishing the
2084 // recents animation into launcher. Defer launching the activity until Launcher is
2085 // next resumed.
Sunny Goyal852537f2020-07-15 17:02:16 -07002086 addOnResumeCallback(() -> startActivitySafely(v, intent, item));
Winson Chungc9bf6d42019-10-04 15:33:18 -07002087 if (mOnDeferredActivityLaunchCallback != null) {
2088 mOnDeferredActivityLaunchCallback.run();
2089 mOnDeferredActivityLaunchCallback = null;
2090 }
Winson Chung0b70cd42019-06-17 22:34:33 -07002091 return true;
2092 }
2093
Sunny Goyal852537f2020-07-15 17:02:16 -07002094 boolean success = super.startActivitySafely(v, intent, item);
Hyunyoung Song1241e612018-05-15 21:46:51 -07002095 if (success && v instanceof BubbleTextView) {
Sunny Goyal0b0847b2018-03-14 12:30:11 -07002096 // This is set to the view that launched the activity that navigated the user away
2097 // from launcher. Since there is no callback for when the activity has finished
2098 // launching, enable the press state and keep this reference to reset the press
2099 // state when we return to launcher.
2100 BubbleTextView btv = (BubbleTextView) v;
2101 btv.setStayPressed(true);
Sunny Goyalb65d7662021-03-07 15:09:11 -08002102 addOnResumeCallback(() -> btv.setStayPressed(false));
Sunny Goyala7ce1662016-05-31 15:01:35 -07002103 }
Hyunyoung Song1241e612018-05-15 21:46:51 -07002104 return success;
Michael Jurka86a720e2012-05-09 11:23:23 -07002105 }
2106
Winson Chung3d503fb2011-07-13 17:25:49 -07002107 boolean isHotseatLayout(View layout) {
Sunny Goyalc13403c2016-11-18 23:44:48 -08002108 // TODO: Remove this method
Sunny Goyal876e4622018-11-02 13:50:40 -07002109 return mHotseat != null && (layout == mHotseat);
Winson Chung3d503fb2011-07-13 17:25:49 -07002110 }
Romain Guy1fbc1c82009-11-09 20:43:08 -08002111
Winson Chung3d503fb2011-07-13 17:25:49 -07002112 /**
2113 * Returns the CellLayout of the specified container at the specified screen.
2114 */
Sunny Goyalefb7e842018-10-04 15:11:00 -07002115 public CellLayout getCellLayout(int container, int screenId) {
Sunny Goyal876e4622018-11-02 13:50:40 -07002116 return (container == LauncherSettings.Favorites.CONTAINER_HOTSEAT)
2117 ? mHotseat : mWorkspace.getScreenWithId(screenId);
Romain Guya6abce82009-11-10 02:54:41 -08002118 }
2119
Michael Jurkae326f182011-11-21 14:05:46 -08002120 @Override
2121 public void onTrimMemory(int level) {
2122 super.onTrimMemory(level);
Adam Cohen3f9c9712014-10-31 11:48:25 -07002123 if (level >= ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN) {
2124 // The widget preview db can result in holding onto over
2125 // 3MB of memory for caching which isn't necessary.
2126 SQLiteDatabase.releaseMemory();
2127
Adam Cohenc8f4e1b2014-11-19 16:03:20 -08002128 // This clears all widget bitmaps from the widget tray
Hyunyoung Song3f471442015-04-08 19:01:34 -07002129 // TODO(hyunyoungs)
Michael Jurkae326f182011-11-21 14:05:46 -08002130 }
2131 }
2132
Michael Jurkad7c28052012-04-27 15:43:36 -07002133 @Override
2134 public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
alanv1d4fde62012-10-17 13:15:47 -07002135 final boolean result = super.dispatchPopulateAccessibilityEvent(event);
Michael Jurkad7c28052012-04-27 15:43:36 -07002136 final List<CharSequence> text = event.getText();
2137 text.clear();
alanv1d4fde62012-10-17 13:15:47 -07002138 // Populate event with a fake title based on the current state.
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07002139 // TODO: When can workspace be null?
2140 text.add(mWorkspace == null
Sunny Goyal52e25452020-07-20 12:38:01 -07002141 ? getString(R.string.home_screen)
Sunny Goyalea609262017-10-25 15:47:38 -07002142 : mStateManager.getState().getDescription(this));
Michael Jurkad7c28052012-04-27 15:43:36 -07002143 return result;
2144 }
2145
Michael Jurka7607c2f2013-04-03 14:33:19 -07002146 /**
Winson Chungc9bf6d42019-10-04 15:33:18 -07002147 * Persistant callback which notifies when an activity launch is deferred because the activity
2148 * was not yet resumed.
2149 */
2150 public void setOnDeferredActivityLaunchCallback(Runnable callback) {
2151 mOnDeferredActivityLaunchCallback = callback;
2152 }
2153
2154 /**
Andras Kloczl55edfe52021-05-14 12:21:30 +02002155 * Sets the next pages to bind synchronously on next bind.
2156 * @param pages should not be null.
Sunny Goyala7a5bf32020-01-05 15:35:29 +05302157 */
Andras Kloczl55edfe52021-05-14 12:21:30 +02002158 public void setPagesToBindSynchronously(@NonNull IntSet pages) {
2159 mPagesToBindSynchronously = pages;
Sunny Goyala7a5bf32020-01-05 15:35:29 +05302160 }
2161
Sunny Goyal93f878c2016-03-30 17:31:24 -07002162 @Override
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002163 public IntSet getPagesToBindSynchronously(IntArray orderedScreenIds) {
Alex Chau49354042021-08-25 13:21:58 +01002164 IntSet visibleIds;
2165 if (!mPagesToBindSynchronously.isEmpty()) {
2166 visibleIds = mPagesToBindSynchronously;
2167 } else if (!mWorkspaceLoading) {
2168 visibleIds = mWorkspace.getCurrentPageScreenIds();
2169 } else {
2170 // If workspace binding is still in progress, getCurrentPageScreenIds won't be accurate,
2171 // and we should use mSynchronouslyBoundPages that's set during initial binding.
2172 visibleIds = mSynchronouslyBoundPages;
2173 }
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002174 IntArray actualIds = new IntArray();
2175
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002176 IntSet result = new IntSet();
2177 if (visibleIds.isEmpty()) {
Schneider Victor-tulias00213382021-09-27 13:41:10 -07002178 if (TestProtocol.sDebugTracing) {
2179 Log.d(TestProtocol.NULL_INT_SET, "getPagesToBindSynchronously (1): "
2180 + result);
2181 }
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002182 return result;
2183 }
2184 for (int id : orderedScreenIds.toArray()) {
Alex Chau1e448462021-08-13 21:48:35 +01002185 actualIds.add(id);
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002186 }
2187 int firstId = visibleIds.getArray().get(0);
Steven Ng4b346102021-09-14 19:17:09 +01002188 int pairId = mWorkspace.getScreenPair(firstId);
Alex Chau62f129b2021-09-03 16:54:27 +01002189 // Double check that actual screenIds contains the visibleId, as empty screens are hidden
2190 // in single panel.
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002191 if (actualIds.contains(firstId)) {
2192 result.add(firstId);
Alex Chau62f129b2021-09-03 16:54:27 +01002193 if (mDeviceProfile.isTwoPanels && actualIds.contains(pairId)) {
2194 result.add(pairId);
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002195 }
Alex Chau62f129b2021-09-03 16:54:27 +01002196 } else if (LauncherAppState.getIDP(this).supportedProfiles.stream().anyMatch(
2197 deviceProfile -> deviceProfile.isTwoPanels) && actualIds.contains(pairId)) {
2198 // Add the right panel if left panel is hidden when switching display, due to empty
2199 // pages being hidden in single panel.
2200 result.add(pairId);
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002201 }
Schneider Victor-tulias00213382021-09-27 13:41:10 -07002202 if (TestProtocol.sDebugTracing) {
2203 Log.d(TestProtocol.NULL_INT_SET, "getPagesToBindSynchronously (2): "
2204 + result);
2205 }
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002206 return result;
Joe Onorato9c1289c2009-08-17 11:03:03 -04002207 }
The Android Open Source Projectf96811c2009-03-18 17:39:48 -07002208
Joe Onorato9c1289c2009-08-17 11:03:03 -04002209 /**
Sunny Goyal527c7d32015-08-28 15:19:36 -07002210 * Clear any pending bind callbacks. This is called when is loader is planning to
2211 * perform a full rebind from scratch.
2212 */
2213 @Override
2214 public void clearPendingBinds() {
Sunny Goyal527c7d32015-08-28 15:19:36 -07002215 if (mPendingExecutor != null) {
Sunny Goyal4a48a982021-06-17 15:15:46 -07002216 mPendingExecutor.cancel();
Sunny Goyal527c7d32015-08-28 15:19:36 -07002217 mPendingExecutor = null;
Sunny Goyal6b6d0a32019-08-05 17:19:32 -07002218
2219 // We might have set this flag previously and forgot to clear it.
2220 mAppsView.getAppsStore()
2221 .disableDeferUpdatesSilently(AllAppsStore.DEFER_UPDATES_NEXT_DRAW);
Sunny Goyal527c7d32015-08-28 15:19:36 -07002222 }
2223 }
2224
2225 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04002226 * Refreshes the shortcuts shown on the workspace.
2227 *
2228 * Implementation of the method from LauncherModel.Callbacks.
2229 */
2230 public void startBinding() {
Winson Chung5cc62c72019-10-16 11:32:41 -07002231 Object traceToken = TraceHelper.INSTANCE.beginSection("startBinding");
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07002232 // Floating panels (except the full widget sheet) are associated with individual icons. If
2233 // we are starting a fresh bind, close all such panels as all the icons are about
2234 // to go away.
Pinyao Tinga74b63a2019-07-17 23:26:06 -07002235 AbstractFloatingView.closeOpenViews(this, true, TYPE_ALL & ~TYPE_REBIND_SAFE);
Jon Miranda6dc7f1e2017-02-21 12:37:51 -08002236
Anjali Koppalff7ceff2014-05-01 18:26:37 -07002237 setWorkspaceLoading(true);
Adam Cohen517a7f52014-03-01 12:12:59 -08002238
Winson Chungd64d1762013-08-20 14:37:16 -07002239 // Clear the workspace because it's going to be rebound
Sunny Goyal2db53422019-03-01 16:06:12 -08002240 mDragController.cancelDrag();
2241
Adam Cohendf035382011-04-11 17:22:04 -07002242 mWorkspace.clearDropTargets();
Winson Chung9e6a0a22013-08-27 11:58:12 -07002243 mWorkspace.removeAllWorkspaceScreens();
Sunny Goyalc11fac32018-02-27 19:20:15 -08002244 mAppWidgetHost.clearViews();
Winson Chungd64d1762013-08-20 14:37:16 -07002245
Winson Chung3d503fb2011-07-13 17:25:49 -07002246 if (mHotseat != null) {
Sunny Goyalc4d32012020-04-03 17:10:11 -07002247 mHotseat.resetLayout(getDeviceProfile().isVerticalBarLayout());
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002248 }
Winson Chung5cc62c72019-10-16 11:32:41 -07002249 TraceHelper.INSTANCE.endSection(traceToken);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002250 }
2251
Adam Cohendcd297f2013-06-18 13:13:40 -07002252 @Override
Sunny Goyalefb7e842018-10-04 15:11:00 -07002253 public void bindScreens(IntArray orderedScreenIds) {
Alex Chau1e448462021-08-13 21:48:35 +01002254 int firstScreenPosition = 0;
Jon Miranda7143ba62019-03-15 09:00:05 -07002255 if (FeatureFlags.QSB_ON_FIRST_SCREEN &&
Andras Kloczldbf577a2021-05-26 15:02:52 +02002256 orderedScreenIds.indexOf(Workspace.FIRST_SCREEN_ID) != firstScreenPosition) {
Sunny Goyalefb7e842018-10-04 15:11:00 -07002257 orderedScreenIds.removeValue(Workspace.FIRST_SCREEN_ID);
Andras Kloczldbf577a2021-05-26 15:02:52 +02002258 orderedScreenIds.add(firstScreenPosition, Workspace.FIRST_SCREEN_ID);
Jon Miranda7143ba62019-03-15 09:00:05 -07002259 } else if (!FeatureFlags.QSB_ON_FIRST_SCREEN && orderedScreenIds.isEmpty()) {
Sunny Goyala9e2f5a2016-06-10 12:22:04 -07002260 // If there are no screens, we need to have an empty screen
Andras Kloczl408a54f2021-08-28 00:59:08 +01002261 mWorkspace.addExtraEmptyScreens();
Adam Cohen5084cba2013-09-03 12:01:16 -07002262 }
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002263 bindAddScreens(orderedScreenIds);
Winson Chung0e6a7132013-08-23 12:55:10 -07002264
Winsonc7d2e832016-07-28 12:24:55 -07002265 // After we have added all the screens, if the wallpaper was locked to the default state,
2266 // then notify to indicate that it can be released and a proper wallpaper offset can be
2267 // computed before the next layout
2268 mWorkspace.unlockWallpaperFromDefaultPageOnNextLayout();
Winson Chung64359a52013-07-08 17:17:08 -07002269 }
2270
Sunny Goyalefb7e842018-10-04 15:11:00 -07002271 private void bindAddScreens(IntArray orderedScreenIds) {
Andras Kloczl8c574de2021-08-17 23:12:17 +02002272 if (mDeviceProfile.isTwoPanels) {
2273 // Some empty pages might have been removed while the phone was in a single panel
2274 // mode, so we want to add those empty pages back.
2275 IntSet screenIds = IntSet.wrap(orderedScreenIds);
Steven Ng4b346102021-09-14 19:17:09 +01002276 orderedScreenIds.forEach(screenId -> screenIds.add(mWorkspace.getScreenPair(screenId)));
Andras Kloczl8c574de2021-08-17 23:12:17 +02002277 orderedScreenIds = screenIds.getArray();
2278 }
2279
Adam Cohendcd297f2013-06-18 13:13:40 -07002280 int count = orderedScreenIds.size();
2281 for (int i = 0; i < count; i++) {
Sunny Goyalefb7e842018-10-04 15:11:00 -07002282 int screenId = orderedScreenIds.get(i);
Andras Kloczldbf577a2021-05-26 15:02:52 +02002283 if (FeatureFlags.QSB_ON_FIRST_SCREEN && screenId == Workspace.FIRST_SCREEN_ID) {
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002284 // No need to bind the first screen, as its always bound.
Andras Kloczldbf577a2021-05-26 15:02:52 +02002285 continue;
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002286 }
Andras Kloczldbf577a2021-05-26 15:02:52 +02002287 mWorkspace.insertNewWorkspaceScreenBeforeEmptyScreen(screenId);
Adam Cohendcd297f2013-06-18 13:13:40 -07002288 }
Adam Cohendcd297f2013-06-18 13:13:40 -07002289 }
2290
Sunny Goyalb23980c2017-08-17 07:45:25 -07002291 @Override
Tony Wickham6a71a5b2018-08-21 11:40:23 -07002292 public void preAddApps() {
2293 // If there's an undo snackbar, force it to complete to ensure empty screens are removed
2294 // before trying to add new items.
2295 mModelWriter.commitDelete();
2296 AbstractFloatingView snackbar = AbstractFloatingView.getOpenView(this, TYPE_SNACKBAR);
2297 if (snackbar != null) {
2298 snackbar.post(() -> snackbar.close(true));
2299 }
2300 }
2301
2302 @Override
Sunny Goyalefb7e842018-10-04 15:11:00 -07002303 public void bindAppsAdded(IntArray newScreens, ArrayList<ItemInfo> addNotAnimated,
Sunny Goyal29947f02017-12-18 13:49:44 -08002304 ArrayList<ItemInfo> addAnimated) {
Winson Chungd64d1762013-08-20 14:37:16 -07002305 // Add the new screens
Adam Cohen76a47a12014-02-05 11:47:43 -08002306 if (newScreens != null) {
Alex Chau817e0fa2021-09-08 20:46:32 +01002307 // newScreens can contain an empty right panel that is already bound, but not known
2308 // by BgDataModel.
2309 newScreens.removeAllValues(mWorkspace.mScreenOrder);
Adam Cohen76a47a12014-02-05 11:47:43 -08002310 bindAddScreens(newScreens);
2311 }
Winson Chungd64d1762013-08-20 14:37:16 -07002312
2313 // We add the items without animation on non-visible pages, and with
2314 // animations on the new page (which we will try and snap to).
Adam Cohen76a47a12014-02-05 11:47:43 -08002315 if (addNotAnimated != null && !addNotAnimated.isEmpty()) {
Sunny Goyalb23980c2017-08-17 07:45:25 -07002316 bindItems(addNotAnimated, false);
Winson Chungd64d1762013-08-20 14:37:16 -07002317 }
Adam Cohen76a47a12014-02-05 11:47:43 -08002318 if (addAnimated != null && !addAnimated.isEmpty()) {
Sunny Goyalb23980c2017-08-17 07:45:25 -07002319 bindItems(addAnimated, true);
Winson Chungd64d1762013-08-20 14:37:16 -07002320 }
Winson Chungc58497e2013-09-03 17:48:37 -07002321
Winson Chung87412982013-10-03 18:34:14 -07002322 // Remove the extra empty screen
Sunny Goyal6e379fc2020-03-19 16:08:14 -07002323 mWorkspace.removeExtraEmptyScreen(false);
Winson Chungd64d1762013-08-20 14:37:16 -07002324 }
2325
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002326 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04002327 * Bind the items start-end from the list.
2328 *
2329 * Implementation of the method from LauncherModel.Callbacks.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002330 */
Tony Wickham0bb211a2015-10-02 16:22:08 -07002331 @Override
Sunny Goyalb23980c2017-08-17 07:45:25 -07002332 public void bindItems(final List<ItemInfo> items, final boolean forceAnimateIcons) {
Schneider Victor-tulias68706eb2021-04-29 15:24:54 -07002333 bindItems(items, forceAnimateIcons, /* focusFirstItemForAccessibility= */ false);
2334 }
2335
2336
2337 /**
2338 * Bind the items start-end from the list.
2339 *
2340 * Implementation of the method from LauncherModel.Callbacks.
2341 *
2342 * @param focusFirstItemForAccessibility true iff the first item to be added to the workspace
2343 * should be focused for accessibility.
2344 */
2345 public void bindItems(
2346 final List<ItemInfo> items,
2347 final boolean forceAnimateIcons,
2348 final boolean focusFirstItemForAccessibility) {
Sunny Goyal3be633b2016-12-08 09:59:25 -08002349 // Get the list of added items and intersect them with the set of items here
Rajeev Kumar43c0f582017-06-23 15:34:55 -07002350 final Collection<Animator> bounceAnims = new ArrayList<>();
Schneider Victor-tulias68fb4162021-09-16 13:24:01 -07002351 boolean canAnimatePageChange = canAnimatePageChange();
Winson Chungf0c6ae02012-03-21 16:10:31 -07002352 Workspace workspace = mWorkspace;
Sunny Goyalefb7e842018-10-04 15:11:00 -07002353 int newItemsScreenId = -1;
Sunny Goyalb23980c2017-08-17 07:45:25 -07002354 int end = items.size();
Schneider Victor-tulias68706eb2021-04-29 15:24:54 -07002355 View newView = null;
Sunny Goyalb23980c2017-08-17 07:45:25 -07002356 for (int i = 0; i < end; i++) {
Sunny Goyal3be633b2016-12-08 09:59:25 -08002357 final ItemInfo item = items.get(i);
Winson Chung4d279d92011-07-21 11:46:32 -07002358
2359 // Short circuit if we are loading dock items for a configuration which has no dock
2360 if (item.container == LauncherSettings.Favorites.CONTAINER_HOTSEAT &&
2361 mHotseat == null) {
2362 continue;
2363 }
2364
Sunny Goyal639e9062015-08-19 19:17:06 -07002365 final View view;
Joe Onorato9c1289c2009-08-17 11:03:03 -04002366 switch (item.itemType) {
2367 case LauncherSettings.Favorites.ITEM_TYPE_APPLICATION:
2368 case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT:
Sunny Goyal3be633b2016-12-08 09:59:25 -08002369 case LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT: {
Sunny Goyal95899162019-03-27 16:03:06 -07002370 WorkspaceItemInfo info = (WorkspaceItemInfo) item;
Sunny Goyal639e9062015-08-19 19:17:06 -07002371 view = createShortcut(info);
Joe Onorato9c1289c2009-08-17 11:03:03 -04002372 break;
Sunny Goyal3be633b2016-12-08 09:59:25 -08002373 }
2374 case LauncherSettings.Favorites.ITEM_TYPE_FOLDER: {
Tracy Zhou4d7b2442019-12-09 13:42:57 -08002375 view = FolderIcon.inflateFolderAndIcon(R.layout.folder_icon, this,
Michael Jurka0142d492010-08-25 17:46:15 -07002376 (ViewGroup) workspace.getChildAt(workspace.getCurrentPage()),
Sunny Goyal1cd01b02016-11-09 10:43:58 -08002377 (FolderInfo) item);
Joe Onorato9c1289c2009-08-17 11:03:03 -04002378 break;
Sunny Goyal3be633b2016-12-08 09:59:25 -08002379 }
Sunny Goyal952e63d2017-08-16 04:59:08 -07002380 case LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET:
2381 case LauncherSettings.Favorites.ITEM_TYPE_CUSTOM_APPWIDGET: {
Sunny Goyala9a1a212017-08-18 01:03:21 -07002382 view = inflateAppWidget((LauncherAppWidgetInfo) item);
Sunny Goyalb23980c2017-08-17 07:45:25 -07002383 if (view == null) {
2384 continue;
Sunny Goyal3be633b2016-12-08 09:59:25 -08002385 }
Sunny Goyal3be633b2016-12-08 09:59:25 -08002386 break;
2387 }
Winson Chungc763c4e2013-07-19 13:49:06 -07002388 default:
2389 throw new RuntimeException("Invalid Item Type");
Joe Onorato9c1289c2009-08-17 11:03:03 -04002390 }
Sunny Goyal639e9062015-08-19 19:17:06 -07002391
Samuel Fufaca37b8a2019-08-19 17:04:36 -07002392 /*
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002393 * Remove colliding items.
2394 */
2395 if (item.container == LauncherSettings.Favorites.CONTAINER_DESKTOP) {
2396 CellLayout cl = mWorkspace.getScreenWithId(item.screenId);
2397 if (cl != null && cl.isOccupied(item.cellX, item.cellY)) {
2398 View v = cl.getChildAt(item.cellX, item.cellY);
Jon Miranda0aff1152021-11-05 16:36:07 -07002399 if (v == null) {
2400 Log.e(TAG, "bindItems failed when removing colliding item=" + item);
2401 }
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002402 Object tag = v.getTag();
2403 String desc = "Collision while binding workspace item: " + item
2404 + ". Collides with " + tag;
Zak Cohen3eeb41d2020-02-14 14:15:13 -08002405 if (FeatureFlags.IS_STUDIO_BUILD) {
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002406 throw (new RuntimeException(desc));
2407 } else {
2408 Log.d(TAG, desc);
Sunny Goyal43bf11d2017-02-02 13:52:53 -08002409 getModelWriter().deleteItemFromDatabase(item);
Jon Miranda701774d2022-02-10 11:09:04 -08002410 if (TestProtocol.sDebugTracing) {
2411 Log.d(TestProtocol.MISSING_PROMISE_ICON,
2412 TAG + "bindItems failed for item=" + item);
2413 }
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07002414 continue;
2415 }
2416 }
2417 }
Sunny Goyald5462aa2016-11-22 16:52:39 +05302418 workspace.addInScreenFromBind(view, item);
Schneider Victor-tulias68fb4162021-09-16 13:24:01 -07002419 if (forceAnimateIcons) {
Sunny Goyal639e9062015-08-19 19:17:06 -07002420 // Animate all the applications up now
2421 view.setAlpha(0f);
2422 view.setScaleX(0f);
2423 view.setScaleY(0f);
2424 bounceAnims.add(createNewAppBounceAnimation(view, i));
Sunny Goyal3be633b2016-12-08 09:59:25 -08002425 newItemsScreenId = item.screenId;
Sunny Goyal639e9062015-08-19 19:17:06 -07002426 }
Schneider Victor-tulias68706eb2021-04-29 15:24:54 -07002427
2428 if (newView == null) {
2429 newView = view;
2430 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002431 }
Winson Chungf0c6ae02012-03-21 16:10:31 -07002432
Schneider Victor-tulias68706eb2021-04-29 15:24:54 -07002433 View viewToFocus = newView;
2434 // Animate to the correct pager
Schneider Victor-tulias68fb4162021-09-16 13:24:01 -07002435 if (forceAnimateIcons && newItemsScreenId > -1) {
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002436 AnimatorSet anim = new AnimatorSet();
2437 anim.playTogether(bounceAnims);
Schneider Victor-tulias68706eb2021-04-29 15:24:54 -07002438 if (focusFirstItemForAccessibility && viewToFocus != null) {
2439 anim.addListener(new AnimatorListenerAdapter() {
2440 @Override
2441 public void onAnimationEnd(Animator animation) {
2442 viewToFocus.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_FOCUSED);
2443 }
2444 });
2445 }
Jon Miranda64eb8ea2018-03-29 11:43:58 -07002446
Sunny Goyalefb7e842018-10-04 15:11:00 -07002447 int currentScreenId = mWorkspace.getScreenIdForPageIndex(mWorkspace.getNextPage());
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002448 final int newScreenIndex = mWorkspace.getPageIndexForScreenId(newItemsScreenId);
2449 final Runnable startBounceAnimRunnable = anim::start;
2450
Schneider Victor-tulias68fb4162021-09-16 13:24:01 -07002451 if (canAnimatePageChange && newItemsScreenId != currentScreenId) {
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002452 // We post the animation slightly delayed to prevent slowdowns
2453 // when we are loading right after we return to launcher.
2454 mWorkspace.postDelayed(new Runnable() {
2455 public void run() {
2456 if (mWorkspace != null) {
Andy Wickham65ced1b2020-03-07 02:14:19 +00002457 closeOpenViews(false);
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002458
2459 mWorkspace.snapToPage(newScreenIndex);
2460 mWorkspace.postDelayed(startBounceAnimRunnable,
2461 NEW_APPS_ANIMATION_DELAY);
Winson Chung94d67682013-09-25 16:29:40 -07002462 }
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002463 }
2464 }, NEW_APPS_PAGE_MOVE_DELAY);
2465 } else {
2466 mWorkspace.postDelayed(startBounceAnimRunnable, NEW_APPS_ANIMATION_DELAY);
Winson Chung997a9232013-07-24 15:33:46 -07002467 }
Schneider Victor-tulias68706eb2021-04-29 15:24:54 -07002468 } else if (focusFirstItemForAccessibility && viewToFocus != null) {
2469 viewToFocus.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_FOCUSED);
Winson Chung64359a52013-07-08 17:17:08 -07002470 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04002471 workspace.requestLayout();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002472 }
2473
Joe Onorato9c1289c2009-08-17 11:03:03 -04002474 /**
2475 * Add the views for a widget to the workspace.
Joe Onorato9c1289c2009-08-17 11:03:03 -04002476 */
Sunny Goyala9a1a212017-08-18 01:03:21 -07002477 public void bindAppWidget(LauncherAppWidgetInfo item) {
2478 View view = inflateAppWidget(item);
2479 if (view != null) {
2480 mWorkspace.addInScreen(view, item);
2481 mWorkspace.requestLayout();
2482 }
2483 }
2484
2485 private View inflateAppWidget(LauncherAppWidgetInfo item) {
Samuel Fufaca37b8a2019-08-19 17:04:36 -07002486 if (item.hasOptionFlag(LauncherAppWidgetInfo.OPTION_SEARCH_WIDGET)) {
2487 item.providerName = QsbContainerView.getSearchComponentName(this);
2488 if (item.providerName == null) {
2489 getModelWriter().deleteItemFromDatabase(item);
2490 return null;
2491 }
2492 }
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002493 final AppWidgetHostView view;
Sunny Goyal2e1efb42016-03-03 16:58:55 -08002494 if (mIsSafeModeEnabled) {
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002495 view = new PendingAppWidgetHostView(this, item, mIconCache, true);
Sunny Goyald5462aa2016-11-22 16:52:39 +05302496 prepareAppWidget(view, item);
Sunny Goyalb23980c2017-08-17 07:45:25 -07002497 return view;
Sunny Goyal2e1efb42016-03-03 16:58:55 -08002498 }
2499
Winson Chung5cc62c72019-10-16 11:32:41 -07002500 Object traceToken = TraceHelper.INSTANCE.beginSection("BIND_WIDGET_id=" + item.appWidgetId);
Joe Onorato9c1289c2009-08-17 11:03:03 -04002501
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002502 try {
2503 final LauncherAppWidgetProviderInfo appWidgetInfo;
Steven Ngacd9d792021-06-25 11:51:44 +01002504 String removalReason = "";
Adam Cohen59400422014-03-05 18:07:04 -08002505
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002506 if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY)) {
2507 // If the provider is not ready, bind as a pending widget.
2508 appWidgetInfo = null;
Steven Ngacd9d792021-06-25 11:51:44 +01002509 removalReason = "the provider isn't ready.";
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002510 } else if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)) {
2511 // The widget id is not valid. Try to find the widget based on the provider info.
2512 appWidgetInfo = mAppWidgetManager.findProvider(item.providerName, item.user);
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002513 if (appWidgetInfo == null) {
2514 if (WidgetsModel.GO_DISABLE_WIDGETS) {
Steven Ngacd9d792021-06-25 11:51:44 +01002515 removalReason = "widgets are disabled on go device.";
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002516 } else {
Steven Ngacd9d792021-06-25 11:51:44 +01002517 removalReason =
2518 "WidgetManagerHelper cannot find a provider from provider info.";
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002519 }
2520 }
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002521 } else {
2522 appWidgetInfo = mAppWidgetManager.getLauncherAppWidgetInfo(item.appWidgetId);
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002523 if (appWidgetInfo == null) {
2524 if (item.appWidgetId <= LauncherAppWidgetInfo.CUSTOM_WIDGET_ID) {
Steven Ngacd9d792021-06-25 11:51:44 +01002525 removalReason =
2526 "CustomWidgetManager cannot find provider from that widget id.";
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002527 } else {
Steven Ngacd9d792021-06-25 11:51:44 +01002528 removalReason = "AppWidgetManager cannot find provider for that widget id."
2529 + " It could be because AppWidgetService is not available, or the"
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002530 + " appWidgetId has not been bound to a the provider yet, or you"
2531 + " don't have access to that appWidgetId.";
2532 }
2533 }
Sunny Goyalff572272014-07-23 13:58:07 -07002534 }
Sunny Goyalff572272014-07-23 13:58:07 -07002535
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002536 // If the provider is ready, but the width is not yet restored, try to restore it.
2537 if (!item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY)
2538 && (item.restoreStatus != LauncherAppWidgetInfo.RESTORE_COMPLETED)) {
2539 if (appWidgetInfo == null) {
Pinyao Tingbbb9a9c2021-05-11 15:42:54 -07002540 FileLog.d(TAG, "Removing restored widget: id=" + item.appWidgetId
2541 + " belongs to component " + item.providerName + " user " + item.user
Steven Ngacd9d792021-06-25 11:51:44 +01002542 + ", as the provider is null and " + removalReason);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002543 getModelWriter().deleteItemFromDatabase(item);
2544 return null;
2545 }
Sunny Goyalff572272014-07-23 13:58:07 -07002546
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002547 // If we do not have a valid id, try to bind an id.
2548 if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)) {
2549 if (!item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_ALLOCATED)) {
2550 // Id has not been allocated yet. Allocate a new id.
2551 item.appWidgetId = mAppWidgetHost.allocateAppWidgetId();
2552 item.restoreStatus |= LauncherAppWidgetInfo.FLAG_ID_ALLOCATED;
Sunny Goyal86df1382016-08-10 15:03:22 -07002553
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002554 // Also try to bind the widget. If the bind fails, the user will be shown
2555 // a click to setup UI, which will ask for the bind permission.
Yogisha Dixit658c5da2021-05-24 23:23:15 +01002556 PendingAddWidgetInfo pendingInfo =
2557 new PendingAddWidgetInfo(appWidgetInfo, item.sourceContainer);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002558 pendingInfo.spanX = item.spanX;
2559 pendingInfo.spanY = item.spanY;
2560 pendingInfo.minSpanX = item.minSpanX;
2561 pendingInfo.minSpanY = item.minSpanY;
Sunny Goyal19ff7282021-04-22 10:12:54 -07002562 Bundle options = pendingInfo.getDefaultSizeOptions(this);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002563
2564 boolean isDirectConfig =
2565 item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_DIRECT_CONFIG);
2566 if (isDirectConfig && item.bindOptions != null) {
2567 Bundle newOptions = item.bindOptions.getExtras();
2568 if (options != null) {
2569 newOptions.putAll(options);
2570 }
2571 options = newOptions;
Sunny Goyal86df1382016-08-10 15:03:22 -07002572 }
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002573 boolean success = mAppWidgetManager.bindAppWidgetIdIfAllowed(
2574 item.appWidgetId, appWidgetInfo, options);
2575
2576 // We tried to bind once. If we were not able to bind, we would need to
2577 // go through the permission dialog, which means we cannot skip the config
2578 // activity.
2579 item.bindOptions = null;
2580 item.restoreStatus &= ~LauncherAppWidgetInfo.FLAG_DIRECT_CONFIG;
2581
2582 // Bind succeeded
2583 if (success) {
2584 // If the widget has a configure activity, it is still needs to set it
2585 // up, otherwise the widget is ready to go.
2586 item.restoreStatus = (appWidgetInfo.configure == null) || isDirectConfig
2587 ? LauncherAppWidgetInfo.RESTORE_COMPLETED
2588 : LauncherAppWidgetInfo.FLAG_UI_NOT_READY;
2589 }
2590
2591 getModelWriter().updateItemInDatabase(item);
Sunny Goyal86df1382016-08-10 15:03:22 -07002592 }
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002593 } else if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_UI_NOT_READY)
2594 && (appWidgetInfo.configure == null)) {
2595 // The widget was marked as UI not ready, but there is no configure activity to
2596 // update the UI.
2597 item.restoreStatus = LauncherAppWidgetInfo.RESTORE_COMPLETED;
Sunny Goyal43bf11d2017-02-02 13:52:53 -08002598 getModelWriter().updateItemInDatabase(item);
Sunny Goyalff572272014-07-23 13:58:07 -07002599 }
Samuel Fufa9151c012020-02-24 17:06:28 -08002600 else if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_UI_NOT_READY)
2601 && appWidgetInfo.configure != null) {
2602 if (mAppWidgetManager.isAppWidgetRestored(item.appWidgetId)) {
2603 item.restoreStatus = LauncherAppWidgetInfo.RESTORE_COMPLETED;
2604 getModelWriter().updateItemInDatabase(item);
2605 }
2606 }
Sunny Goyal56c73602015-09-25 12:55:01 -07002607 }
2608
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002609 if (item.restoreStatus == LauncherAppWidgetInfo.RESTORE_COMPLETED) {
2610 // Verify that we own the widget
2611 if (appWidgetInfo == null) {
Pinyao Ting0d97f8d2020-12-04 15:12:26 -08002612 FileLog.e(TAG, "Removing invalid widget: id=" + item.appWidgetId);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002613 getModelWriter().deleteWidgetInfo(item, getAppWidgetHost());
2614 return null;
2615 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04002616
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002617 item.minSpanX = appWidgetInfo.minSpanX;
2618 item.minSpanY = appWidgetInfo.minSpanY;
2619 view = mAppWidgetHost.createView(this, item.appWidgetId, appWidgetInfo);
Samuel Fufa9151c012020-02-24 17:06:28 -08002620 } else if (!item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)
2621 && appWidgetInfo != null) {
2622 mAppWidgetHost.addPendingView(item.appWidgetId,
2623 new PendingAppWidgetHostView(this, item, mIconCache, false));
2624 view = mAppWidgetHost.createView(this, item.appWidgetId, appWidgetInfo);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002625 } else {
2626 view = new PendingAppWidgetHostView(this, item, mIconCache, false);
2627 }
2628 prepareAppWidget(view, item);
2629 } finally {
Winson Chung5cc62c72019-10-16 11:32:41 -07002630 TraceHelper.INSTANCE.endSection(traceToken);
Sunny Goyal17c72fb2019-10-14 14:06:38 -07002631 }
2632
Sunny Goyalb23980c2017-08-17 07:45:25 -07002633 return view;
Joe Onorato9c1289c2009-08-17 11:03:03 -04002634 }
2635
Sunny Goyalff572272014-07-23 13:58:07 -07002636 /**
2637 * Restores a pending widget.
2638 *
2639 * @param appWidgetId The app widget id
Sunny Goyalff572272014-07-23 13:58:07 -07002640 */
Sunny Goyald478c832016-04-01 12:04:16 -07002641 private LauncherAppWidgetInfo completeRestoreAppWidget(int appWidgetId, int finalRestoreFlag) {
Sunny Goyalff572272014-07-23 13:58:07 -07002642 LauncherAppWidgetHostView view = mWorkspace.getWidgetForAppWidgetId(appWidgetId);
2643 if ((view == null) || !(view instanceof PendingAppWidgetHostView)) {
2644 Log.e(TAG, "Widget update called, when the widget no longer exists.");
Sunny Goyald478c832016-04-01 12:04:16 -07002645 return null;
Sunny Goyalff572272014-07-23 13:58:07 -07002646 }
2647
Sunny Goyal0fc1be12014-08-11 17:05:23 -07002648 LauncherAppWidgetInfo info = (LauncherAppWidgetInfo) view.getTag();
Sunny Goyald478c832016-04-01 12:04:16 -07002649 info.restoreStatus = finalRestoreFlag;
Jon Miranda2b823f42017-05-02 18:36:18 -07002650 if (info.restoreStatus == LauncherAppWidgetInfo.RESTORE_COMPLETED) {
2651 info.pendingItemInfo = null;
2652 }
Sunny Goyalff572272014-07-23 13:58:07 -07002653
Sunny Goyalba47faa2017-10-04 16:50:57 -07002654 if (((PendingAppWidgetHostView) view).isReinflateIfNeeded()) {
Sunny Goyal29947f02017-12-18 13:49:44 -08002655 view.reInflate();
Sunny Goyalba47faa2017-10-04 16:50:57 -07002656 }
2657
Sunny Goyal43bf11d2017-02-02 13:52:53 -08002658 getModelWriter().updateItemInDatabase(info);
Sunny Goyald478c832016-04-01 12:04:16 -07002659 return info;
Sunny Goyalff572272014-07-23 13:58:07 -07002660 }
2661
Sunny Goyal527c7d32015-08-28 15:19:36 -07002662 public void clearPendingExecutor(ViewOnDrawExecutor executor) {
2663 if (mPendingExecutor == executor) {
2664 mPendingExecutor = null;
2665 }
2666 }
2667
Sunny Goyalb5b9ad62016-04-02 11:23:39 -07002668 @Override
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -07002669 @TargetApi(Build.VERSION_CODES.S)
Sunny Goyal4a48a982021-06-17 15:15:46 -07002670 public void onInitialBindComplete(IntSet boundPages, RunnableList pendingTasks) {
2671 mSynchronouslyBoundPages = boundPages;
Sunny Goyal4a48a982021-06-17 15:15:46 -07002672 mPagesToBindSynchronously = new IntSet();
2673
2674 clearPendingBinds();
2675 ViewOnDrawExecutor executor = new ViewOnDrawExecutor(pendingTasks);
2676 mPendingExecutor = executor;
2677 if (!isInState(ALL_APPS)) {
2678 mAppsView.getAppsStore().enableDeferUpdates(AllAppsStore.DEFER_UPDATES_NEXT_DRAW);
2679 pendingTasks.add(() -> mAppsView.getAppsStore().disableDeferUpdates(
2680 AllAppsStore.DEFER_UPDATES_NEXT_DRAW));
2681 }
2682
Sunny Goyal6001ea22018-05-10 16:31:00 -07002683 AlphaProperty property = mDragLayer.getAlphaProperty(ALPHA_INDEX_LAUNCHER_LOAD);
2684 if (property.getValue() < 1) {
2685 ObjectAnimator anim = ObjectAnimator.ofFloat(property, MultiValueAlpha.VALUE, 1);
Sunny Goyal4a48a982021-06-17 15:15:46 -07002686 anim.addListener(AnimatorListeners.forEndCallback(executor::onLoadAnimationCompleted));
Sunny Goyal6001ea22018-05-10 16:31:00 -07002687 anim.start();
Sunny Goyal4a48a982021-06-17 15:15:46 -07002688 } else {
Sunny Goyal29947f02017-12-18 13:49:44 -08002689 executor.onLoadAnimationCompleted();
Sunny Goyalb5b9ad62016-04-02 11:23:39 -07002690 }
Sunny Goyal4a48a982021-06-17 15:15:46 -07002691 executor.attachTo(this);
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -07002692 if (Utilities.ATLEAST_S) {
2693 Trace.endAsyncSection(DISPLAY_WORKSPACE_TRACE_METHOD_NAME,
2694 DISPLAY_WORKSPACE_TRACE_COOKIE);
2695 }
Sunny Goyalb5b9ad62016-04-02 11:23:39 -07002696 }
2697
Joe Onorato9c1289c2009-08-17 11:03:03 -04002698 /**
2699 * Callback saying that there aren't any more items to bind.
2700 *
2701 * Implementation of the method from LauncherModel.Callbacks.
2702 */
Andras Kloczl55edfe52021-05-14 12:21:30 +02002703 public void finishBindingItems(IntSet pagesBoundFirst) {
Winson Chung5cc62c72019-10-16 11:32:41 -07002704 Object traceToken = TraceHelper.INSTANCE.beginSection("finishBindingItems");
Adam Cohen1462de32012-07-24 22:34:36 -07002705 mWorkspace.restoreInstanceStateForRemainingPages();
Joe Onorato9c1289c2009-08-17 11:03:03 -04002706
Anjali Koppalff7ceff2014-05-01 18:26:37 -07002707 setWorkspaceLoading(false);
Adam Cohendb364c32014-05-20 14:23:40 -07002708
Sunny Goyal2100c782016-08-22 16:00:03 -07002709 if (mPendingActivityResult != null) {
2710 handleActivityResult(mPendingActivityResult.requestCode,
2711 mPendingActivityResult.resultCode, mPendingActivityResult.data);
2712 mPendingActivityResult = null;
Adam Cohendb364c32014-05-20 14:23:40 -07002713 }
2714
Andras Kloczl55edfe52021-05-14 12:21:30 +02002715 int currentPage = pagesBoundFirst != null && !pagesBoundFirst.isEmpty()
Sunny Goyal12e3f1f2021-07-15 14:31:58 -07002716 ? mWorkspace.getPageIndexForScreenId(pagesBoundFirst.getArray().get(0))
2717 : PagedView.INVALID_PAGE;
Tonyf80e8932018-12-21 11:58:04 -08002718 // When undoing the removal of the last item on a page, return to that page.
Tony Wickham03f27012019-04-25 14:22:54 -07002719 // Since we are just resetting the current page without user interaction,
2720 // override the previous page so we don't log the page switch.
Andras Kloczl55edfe52021-05-14 12:21:30 +02002721 mWorkspace.setCurrentPage(currentPage, currentPage /* overridePrevPage */);
2722 mPagesToBindSynchronously = new IntSet();
Tony Wickham6a71a5b2018-08-21 11:40:23 -07002723
Sunny Goyalac6f69f2019-08-16 11:59:55 -07002724 // Cache one page worth of icons
2725 getViewCache().setCacheSize(R.layout.folder_application,
2726 mDeviceProfile.inv.numFolderColumns * mDeviceProfile.inv.numFolderRows);
2727 getViewCache().setCacheSize(R.layout.folder_page, 2);
2728
Winson Chung5cc62c72019-10-16 11:32:41 -07002729 TraceHelper.INSTANCE.endSection(traceToken);
Winson Chungf0c6ae02012-03-21 16:10:31 -07002730 }
2731
Schneider Victor-tulias68fb4162021-09-16 13:24:01 -07002732 private boolean canAnimatePageChange() {
Sunny Goyal9b180102020-03-11 10:02:29 -07002733 if (mDragController.isDragging()) {
2734 return false;
2735 } else {
Riddle Hsu979da642020-09-22 21:52:40 +08002736 return (SystemClock.uptimeMillis() - mLastTouchUpTime)
Sunny Goyal9b180102020-03-11 10:02:29 -07002737 > (NEW_APPS_ANIMATION_INACTIVE_TIMEOUT_SECONDS * 1000);
2738 }
Winson Chunga2413752012-04-03 14:22:34 -07002739 }
2740
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002741 /**
2742 * Similar to {@link #getFirstMatch} but optimized to finding a suitable view for the app close
2743 * animation.
2744 *
2745 * @param preferredItemId The id of the preferred item to match to if it exists.
2746 * @param packageName The package name of the app to match.
2747 * @param user The user of the app to match.
2748 */
2749 public View getFirstMatchForAppClose(int preferredItemId, String packageName, UserHandle user) {
2750 final ItemInfoMatcher preferredItem = (info, cn) ->
2751 info != null && info.id == preferredItemId;
2752 final ItemInfoMatcher packageAndUserAndApp = (info, cn) ->
2753 info != null
2754 && info.itemType == ITEM_TYPE_APPLICATION
2755 && info.user.equals(user)
2756 && info.getTargetComponent() != null
2757 && TextUtils.equals(info.getTargetComponent().getPackageName(),
2758 packageName);
2759
2760 if (isInState(LauncherState.ALL_APPS)) {
2761 return getFirstMatch(Collections.singletonList(mAppsView.getActiveRecyclerView()),
2762 preferredItem, packageAndUserAndApp);
2763 } else {
2764 List<ViewGroup> containers = new ArrayList<>(mWorkspace.getPanelCount() + 1);
2765 containers.add(mWorkspace.getHotseat().getShortcutsAndWidgets());
2766 mWorkspace.forEachVisiblePage(page
2767 -> containers.add(((CellLayout) page).getShortcutsAndWidgets()));
2768
2769 // Order: Preferred item by itself or in folder, then by matching package/user
Jon Miranda78d0d4f2022-01-24 18:00:04 -08002770 return getFirstMatch(containers, preferredItem, forFolderMatch(preferredItem),
2771 packageAndUserAndApp, forFolderMatch(packageAndUserAndApp));
Jon Mirandac4a99bf2021-11-04 16:53:45 -07002772 }
2773 }
2774
2775 /**
2776 * Finds the first view matching the ordered operators across the given viewgroups in order.
2777 * @param containers List of ViewGroups to scan, in order of preference.
2778 * @param operators List of operators, in order starting from best matching operator.
2779 */
2780 private static View getFirstMatch(Iterable<ViewGroup> containers,
2781 final ItemInfoMatcher... operators) {
2782 for (ItemInfoMatcher operator : operators) {
2783 for (ViewGroup container : containers) {
2784 View match = mapOverViewGroup(container, operator);
2785 if (match != null) {
2786 return match;
2787 }
2788 }
2789 }
2790 return null;
2791 }
2792
2793 /**
2794 * Returns the first view matching the operator in the given ViewGroups, or null if none.
2795 * Forward iteration matters.
2796 */
2797 private static View mapOverViewGroup(ViewGroup container, ItemInfoMatcher op) {
2798 final int itemCount = container.getChildCount();
2799 for (int itemIdx = 0; itemIdx < itemCount; itemIdx++) {
2800 View item = container.getChildAt(itemIdx);
2801 if (op.matchesInfo((ItemInfo) item.getTag())) {
2802 return item;
2803 }
2804 }
2805 return null;
2806 }
2807
Winson Chungc9168342013-06-26 14:54:55 -07002808 private ValueAnimator createNewAppBounceAnimation(View v, int i) {
Sunny Goyalf0b6db72018-08-13 16:10:14 -07002809 ValueAnimator bounceAnim = new PropertyListBuilder().alpha(1).scale(1).build(v)
Sunny Goyal60e68c92020-08-12 13:59:27 -07002810 .setDuration(ItemInstallQueue.NEW_SHORTCUT_BOUNCE_DURATION);
2811 bounceAnim.setStartDelay(i * ItemInstallQueue.NEW_SHORTCUT_STAGGER_DELAY);
Sunny Goyal5a1f53b2015-05-27 10:24:24 -07002812 bounceAnim.setInterpolator(new OvershootInterpolator(BOUNCE_ANIMATION_TENSION));
Winson Chungc9168342013-06-26 14:54:55 -07002813 return bounceAnim;
2814 }
2815
Pinyao Tingc9074272019-11-11 11:51:44 -08002816 private void announceForAccessibility(@StringRes int stringResId) {
2817 getDragLayer().announceForAccessibility(getString(stringResId));
2818 }
2819
Amith Yamasani6d7fe502010-11-16 09:05:07 -08002820 /**
Josh Tsuji231c9222022-01-11 20:43:59 -05002821 * Informs us that the overlay (-1 screen, typically), has either become visible or invisible.
2822 */
2823 public void onOverlayVisibilityChanged(boolean visible) {}
2824
2825 /**
2826 * Informs us that the page transition has ended, so that we can react to the newly selected
2827 * page if we want to.
2828 */
2829 public void onPageEndTransition() {}
2830
2831 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04002832 * Add the icons for all apps.
2833 *
2834 * Implementation of the method from LauncherModel.Callbacks.
2835 */
Sunny Goyal28daf4a2020-06-08 17:06:09 -07002836 @Override
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -07002837 @TargetApi(Build.VERSION_CODES.S)
Sunny Goyal28daf4a2020-06-08 17:06:09 -07002838 public void bindAllApplications(AppInfo[] apps, int flags) {
2839 mAppsView.getAppsStore().setApps(apps, flags);
Sunny Goyal1818fb72020-11-09 14:32:48 -08002840 PopupContainerWithArrow.dismissInvalidPopup(this);
Schneider Victor-tulias927d6dc2021-08-26 11:56:47 -07002841 if (Utilities.ATLEAST_S) {
2842 Trace.endAsyncSection(DISPLAY_ALL_APPS_TRACE_METHOD_NAME,
2843 DISPLAY_ALL_APPS_TRACE_COOKIE);
2844 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04002845 }
2846
2847 /**
Zak Cohen658c67a2018-10-19 14:21:05 -07002848 * Copies LauncherModel's map of activities to shortcut counts to Launcher's. This is necessary
Tony Wickhambfbf7f92016-05-19 11:19:39 -07002849 * because LauncherModel's map is updated in the background, while Launcher runs on the UI.
2850 */
2851 @Override
Zak Cohen658c67a2018-10-19 14:21:05 -07002852 public void bindDeepShortcutMap(HashMap<ComponentKey, Integer> deepShortcutMapCopy) {
Tony Wickham010d2552017-01-20 08:15:28 -08002853 mPopupDataProvider.setDeepShortcutMap(deepShortcutMapCopy);
Tony Wickham1bce7fd2016-04-28 17:39:03 -07002854 }
2855
Sunny Goyal4390ace2014-10-13 11:33:11 -07002856 @Override
Schneider Victor-tulias6a5f4312021-01-12 19:30:02 +00002857 public void bindIncrementalDownloadProgressUpdated(AppInfo app) {
2858 mAppsView.getAppsStore().updateProgressBar(app);
Mario Bertschler08ffaae2017-03-20 11:30:27 -07002859 }
2860
2861 @Override
Sunny Goyal29947f02017-12-18 13:49:44 -08002862 public void bindWidgetsRestored(ArrayList<LauncherAppWidgetInfo> widgets) {
Sunny Goyal4390ace2014-10-13 11:33:11 -07002863 mWorkspace.widgetsRestored(widgets);
2864 }
2865
Joe Onorato9c1289c2009-08-17 11:03:03 -04002866 /**
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07002867 * Some shortcuts were updated in the background.
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07002868 * Implementation of the method from LauncherModel.Callbacks.
Sunny Goyald3b87ef2016-07-28 12:11:54 -07002869 *
2870 * @param updated list of shortcuts which have changed.
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07002871 */
Sunny Goyal4390ace2014-10-13 11:33:11 -07002872 @Override
Sunny Goyal28f50752020-07-21 14:15:13 -07002873 public void bindWorkspaceItemsChanged(List<WorkspaceItemInfo> updated) {
Sunny Goyal4390ace2014-10-13 11:33:11 -07002874 if (!updated.isEmpty()) {
Sunny Goyal711c5962021-06-23 12:36:18 -07002875 mWorkspace.updateWorkspaceItems(updated, this);
Sunny Goyal1818fb72020-11-09 14:32:48 -08002876 PopupContainerWithArrow.dismissInvalidPopup(this);
Sunny Goyal4390ace2014-10-13 11:33:11 -07002877 }
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07002878 }
2879
2880 /**
Chris Wrenaeff7ea2014-02-14 16:59:24 -05002881 * Update the state of a package, typically related to install state.
2882 *
2883 * Implementation of the method from LauncherModel.Callbacks.
2884 */
Sunny Goyale755d462014-07-22 13:48:29 -07002885 @Override
Sunny Goyal29947f02017-12-18 13:49:44 -08002886 public void bindRestoreItemsChange(HashSet<ItemInfo> updates) {
Sunny Goyal711c5962021-06-23 12:36:18 -07002887 mWorkspace.updateRestoreItems(updates, this);
Sunny Goyala22666f2014-09-18 13:25:15 -07002888 }
2889
2890 /**
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07002891 * A package was uninstalled/updated. We take both the super set of packageNames
Winson Chung83892cc2013-05-01 16:53:33 -07002892 * in addition to specific applications to remove, the reason being that
2893 * this can be called when a package is updated as well. In that scenario,
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07002894 * we only remove specific components from the workspace and hotseat, where as
Winson Chung83892cc2013-05-01 16:53:33 -07002895 * package-removal should clear all items by package name.
Joe Onorato9c1289c2009-08-17 11:03:03 -04002896 */
Sunny Goyal1a745e82014-10-02 15:58:31 -07002897 @Override
Sunny Goyal6e13dd32017-08-17 03:01:19 -07002898 public void bindWorkspaceComponentsRemoved(final ItemInfoMatcher matcher) {
Sunny Goyal6e13dd32017-08-17 03:01:19 -07002899 mWorkspace.removeItemsByMatcher(matcher);
2900 mDragController.onAppsRemoved(matcher);
Sunny Goyal1818fb72020-11-09 14:32:48 -08002901 PopupContainerWithArrow.dismissInvalidPopup(this);
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07002902 }
Sunny Goyal4390ace2014-10-13 11:33:11 -07002903
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07002904 @Override
Steven Ng2f5648a2021-02-08 17:18:25 +00002905 public void bindAllWidgets(final List<WidgetsListBaseEntry> allWidgets) {
Sunny Goyalf1fbc3f2017-10-10 15:21:15 -07002906 mPopupDataProvider.setAllWidgets(allWidgets);
Tony Wickham26b17462017-03-20 17:12:24 -07002907 }
2908
kholoud mohamedc76b2032021-12-20 16:47:38 +00002909 @Override
2910 public void bindStringCache(StringCache cache) {
2911 mStringCache = cache;
2912 }
2913
2914 @Override
2915 public StringCache getStringCache() {
2916 return mStringCache;
2917 }
2918
Tony Wickham86222d22017-03-29 15:30:43 -07002919 /**
2920 * @param packageUser if null, refreshes all widgets and shortcuts, otherwise only
2921 * refreshes the widgets and shortcuts associated with the given package/user
2922 */
2923 public void refreshAndBindWidgetsForPackageUser(@Nullable PackageUserKey packageUser) {
Sunny Goyalc6e97692017-06-02 13:46:55 -07002924 mModel.refreshAndBindWidgetsAndShortcuts(packageUser);
Sunny Goyal2e1efb42016-03-03 16:58:55 -08002925 }
2926
Winson Chung80baf5a2010-08-09 16:03:15 -07002927 /**
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08002928 * $ adb shell dumpsys activity com.android.launcher3.Launcher [--all]
Joe Onoratobe386092009-11-17 17:32:16 -08002929 */
Adam Cohen16d7ffc2011-10-05 17:49:14 -07002930 @Override
2931 public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) {
2932 super.dump(prefix, fd, writer, args);
Sunny Goyala1365452015-10-01 15:46:24 -07002933
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08002934 if (args.length > 0 && TextUtils.equals(args[0], "--all")) {
2935 writer.println(prefix + "Workspace Items");
Sunny Goyal7ce471b2017-08-02 03:37:39 -07002936 for (int i = 0; i < mWorkspace.getPageCount(); i++) {
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08002937 writer.println(prefix + " Homescreen " + i);
2938
2939 ViewGroup layout = ((CellLayout) mWorkspace.getPageAt(i)).getShortcutsAndWidgets();
2940 for (int j = 0; j < layout.getChildCount(); j++) {
2941 Object tag = layout.getChildAt(j).getTag();
2942 if (tag != null) {
2943 writer.println(prefix + " " + tag.toString());
2944 }
2945 }
2946 }
2947
2948 writer.println(prefix + " Hotseat");
Sunny Goyal876e4622018-11-02 13:50:40 -07002949 ViewGroup layout = mHotseat.getShortcutsAndWidgets();
Sunny Goyala1365452015-10-01 15:46:24 -07002950 for (int j = 0; j < layout.getChildCount(); j++) {
2951 Object tag = layout.getChildAt(j).getTag();
2952 if (tag != null) {
2953 writer.println(prefix + " " + tag.toString());
2954 }
Adam Cohen4caf2982013-08-20 18:54:31 -07002955 }
Sunny Goyala1365452015-10-01 15:46:24 -07002956 }
2957
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08002958 writer.println(prefix + "Misc:");
Winson Chungef528762019-09-06 12:05:52 -07002959 dumpMisc(prefix + "\t", writer);
2960 writer.println(prefix + "\tmWorkspaceLoading=" + mWorkspaceLoading);
2961 writer.println(prefix + "\tmPendingRequestArgs=" + mPendingRequestArgs
2962 + " mPendingActivityResult=" + mPendingActivityResult);
2963 writer.println(prefix + "\tmRotationHelper: " + mRotationHelper);
2964 writer.println(prefix + "\tmAppWidgetHost.isListening: " + mAppWidgetHost.isListening());
2965
Tony Wickham646e4482020-04-06 17:25:53 -07002966 // Extra logging for general debugging
Hyunyoung Songa310a802019-04-25 13:57:16 -07002967 mDragLayer.dump(prefix, writer);
2968 mStateManager.dump(prefix, writer);
Tony Wickham646e4482020-04-06 17:25:53 -07002969 mPopupDataProvider.dump(prefix, writer);
Jon Miranda58561d42021-03-17 10:51:54 -04002970 mDeviceProfile.dump(prefix, writer);
Sunny Goyal2bba1902018-02-27 12:20:50 -08002971
2972 try {
2973 FileLog.flushAll(writer);
2974 } catch (Exception e) {
2975 // Ignore
2976 }
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08002977
2978 mModel.dumpState(prefix, fd, writer, args);
Sunny Goyala1365452015-10-01 15:46:24 -07002979
Adam Cohen9211d422014-10-07 18:14:53 -07002980 if (mLauncherCallbacks != null) {
2981 mLauncherCallbacks.dump(prefix, fd, writer, args);
2982 }
Sunny Goyalb1d7de22019-09-06 10:36:54 -07002983 mOverlayManager.dump(prefix, writer);
Adam Cohen16d7ffc2011-10-05 17:49:14 -07002984 }
Adam Cohen487f7dd2012-06-28 18:12:10 -07002985
Sunny Goyal66b24572016-09-21 15:57:55 -07002986 @Override
Sunny Goyal66b24572016-09-21 15:57:55 -07002987 public void onProvideKeyboardShortcuts(
2988 List<KeyboardShortcutGroup> data, Menu menu, int deviceId) {
2989
2990 ArrayList<KeyboardShortcutInfo> shortcutInfos = new ArrayList<>();
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07002991 if (isInState(NORMAL)) {
Sunny Goyal66b24572016-09-21 15:57:55 -07002992 shortcutInfos.add(new KeyboardShortcutInfo(getString(R.string.all_apps_button_label),
2993 KeyEvent.KEYCODE_A, KeyEvent.META_CTRL_ON));
Vadim Tryshev74c261c2018-06-12 13:44:43 -07002994 shortcutInfos.add(new KeyboardShortcutInfo(getString(R.string.widget_button_text),
2995 KeyEvent.KEYCODE_W, KeyEvent.META_CTRL_ON));
Sunny Goyal66b24572016-09-21 15:57:55 -07002996 }
Sunny Goyal384b5782021-02-09 22:50:02 -08002997 getSupportedActions(this, getCurrentFocus()).forEach(la ->
Vadim Tryshev3455f8d2018-05-11 20:02:20 -07002998 shortcutInfos.add(new KeyboardShortcutInfo(
Sunny Goyal384b5782021-02-09 22:50:02 -08002999 la.accessibilityAction.getLabel(), la.keyCode, KeyEvent.META_CTRL_ON)));
Sunny Goyal66b24572016-09-21 15:57:55 -07003000 if (!shortcutInfos.isEmpty()) {
3001 data.add(new KeyboardShortcutGroup(getString(R.string.home_screen), shortcutInfos));
3002 }
3003
3004 super.onProvideKeyboardShortcuts(data, menu, deviceId);
3005 }
3006
3007 @Override
3008 public boolean onKeyShortcut(int keyCode, KeyEvent event) {
3009 if (event.hasModifiers(KeyEvent.META_CTRL_ON)) {
3010 switch (keyCode) {
3011 case KeyEvent.KEYCODE_A:
Sunny Goyal3e3f44c2017-10-23 17:14:52 -07003012 if (isInState(NORMAL)) {
3013 getStateManager().goToState(ALL_APPS);
Sunny Goyal66b24572016-09-21 15:57:55 -07003014 return true;
3015 }
3016 break;
Vadim Tryshev74c261c2018-06-12 13:44:43 -07003017 case KeyEvent.KEYCODE_W:
3018 if (isInState(NORMAL)) {
3019 OptionsPopupView.openWidgets(this);
3020 return true;
3021 }
3022 break;
Sunny Goyal384b5782021-02-09 22:50:02 -08003023 default:
3024 for (LauncherAction la : getSupportedActions(this, getCurrentFocus())) {
3025 if (la.keyCode == keyCode) {
3026 return la.invokeFromKeyboard(getCurrentFocus());
3027 }
3028 }
Sunny Goyal66b24572016-09-21 15:57:55 -07003029 }
3030 }
3031 return super.onKeyShortcut(keyCode, event);
3032 }
3033
Vadim Tryshev646a0dd2018-02-05 16:27:50 -08003034 @Override
3035 public boolean onKeyUp(int keyCode, KeyEvent event) {
3036 if (keyCode == KeyEvent.KEYCODE_MENU) {
3037 // KEYCODE_MENU is sent by some tests, for example
3038 // LauncherJankTests#testWidgetsContainerFling. Don't just remove its handling.
3039 if (!mDragController.isDragging() && !mWorkspace.isSwitchingState() &&
3040 isInState(NORMAL)) {
3041 // Close any open floating views.
Andy Wickham65ced1b2020-03-07 02:14:19 +00003042 closeOpenViews();
Vadim Tryshev646a0dd2018-02-05 16:27:50 -08003043
3044 // Setting the touch point to (-1, -1) will show the options popup in the center of
3045 // the screen.
vadimtbc5d7e62019-12-09 13:53:05 -08003046 if (Utilities.IS_RUNNING_IN_TEST_HARNESS) {
3047 Log.d(TestProtocol.PERMANENT_DIAG_TAG, "Opening options popup on key up");
3048 }
Sunny Goyal831212e2021-05-14 14:24:09 -07003049 showDefaultOptions(-1, -1);
Vadim Tryshev646a0dd2018-02-05 16:27:50 -08003050 }
3051 return true;
3052 }
3053 return super.onKeyUp(keyCode, event);
3054 }
3055
Sunny Goyal831212e2021-05-14 14:24:09 -07003056 /**
3057 * Shows the default options popup
3058 */
3059 public void showDefaultOptions(float x, float y) {
Brian Isganitisa85ae692021-09-23 19:56:24 -04003060 OptionsPopupView.show(this, getPopupTarget(x, y), OptionsPopupView.getOptions(this),
3061 false);
3062 }
3063
3064 /**
3065 * Returns target rectangle for anchoring a popup menu.
3066 */
3067 protected RectF getPopupTarget(float x, float y) {
Sunny Goyal831212e2021-05-14 14:24:09 -07003068 float halfSize = getResources().getDimension(R.dimen.options_menu_thumb_size) / 2;
3069 if (x < 0 || y < 0) {
3070 x = mDragLayer.getWidth() / 2;
3071 y = mDragLayer.getHeight() / 2;
3072 }
Brian Isganitisa85ae692021-09-23 19:56:24 -04003073 return new RectF(x - halfSize, y - halfSize, x + halfSize, y + halfSize);
3074 }
3075
3076 @Override
3077 public boolean shouldUseColorExtractionForPopup() {
3078 return getTopOpenViewWithType(this, TYPE_FOLDER) == null
3079 && getStateManager().getState() != LauncherState.ALL_APPS;
Sunny Goyal831212e2021-05-14 14:24:09 -07003080 }
3081
Sunny Goyalb5181c82021-03-10 07:39:12 +00003082 @Override
3083 protected void collectStateHandlers(List<StateHandler> out) {
3084 out.add(getAllAppsController());
3085 out.add(getWorkspace());
Andrew Sappersteinabef55a2016-06-19 12:49:00 -07003086 }
3087
Sunny Goyal210e1742019-10-17 12:05:38 -07003088 public TouchController[] createTouchControllers() {
3089 return new TouchController[] {getDragController(), new AllAppsSwipeController(this)};
3090 }
3091
Sunny Goyal210e1742019-10-17 12:05:38 -07003092 public void useFadeOutAnimationForLauncherStart(CancellationSignal signal) { }
3093
3094 public void onDragLayerHierarchyChanged() { }
3095
Vinit Nayakf9b585b2019-07-10 14:25:32 -07003096 @Override
3097 public void returnToHomescreen() {
3098 super.returnToHomescreen();
3099 getStateManager().goToState(LauncherState.NORMAL);
3100 }
3101
Andy Wickham65ced1b2020-03-07 02:14:19 +00003102 private void closeOpenViews() {
3103 closeOpenViews(true);
3104 }
3105
3106 protected void closeOpenViews(boolean animate) {
3107 AbstractFloatingView.closeAllOpenViews(this, animate);
3108 }
3109
Sunny Goyal3a1eadd2019-10-23 17:44:27 -07003110 public Stream<SystemShortcut.Factory> getSupportedShortcuts() {
Samuel Fufa5cf3e862020-02-03 20:22:54 -08003111 return Stream.of(APP_INFO, WIDGETS, INSTALL);
Sunny Goyal3a1eadd2019-10-23 17:44:27 -07003112 }
3113
Sunny Goyal384b5782021-02-09 22:50:02 -08003114 protected LauncherAccessibilityDelegate createAccessibilityDelegate() {
3115 return new LauncherAccessibilityDelegate(this);
3116 }
Sunny Goyalf2393f12020-04-01 20:13:12 -07003117
3118 /**
3119 * @see LauncherState#getOverviewScaleAndOffset(Launcher)
3120 */
3121 public float[] getNormalOverviewScaleAndOffset() {
Tony Wickham82d5a062021-05-14 14:37:12 -07003122 return new float[] {NO_SCALE, NO_OFFSET};
Sunny Goyalf2393f12020-04-01 20:13:12 -07003123 }
3124
Sunny Goyal210e1742019-10-17 12:05:38 -07003125 public static Launcher getLauncher(Context context) {
Winson Chung8687bc22020-02-27 23:34:24 -08003126 return fromContext(context);
Sunny Goyal210e1742019-10-17 12:05:38 -07003127 }
3128
Sunny Goyal3dce5f32017-10-05 11:40:05 -07003129 /**
Sunny Goyalab770a12018-11-14 15:17:26 -08003130 * Just a wrapper around the type cast to allow easier tracking of calls.
3131 */
3132 public static <T extends Launcher> T cast(ActivityContext activityContext) {
3133 return (T) activityContext;
3134 }
3135
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -07003136 /**
3137 * Cross-fades the launcher's updated appearance with its previous appearance.
3138 *
3139 * This method is used to cross-fade UI updates on activity creation, specifically dark mode
3140 * updates.
3141 */
3142 private void crossFadeWithPreviousAppearance() {
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08003143 NonConfigInstance lastInstance = (NonConfigInstance) getLastNonConfigurationInstance();
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -07003144
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08003145 if (lastInstance == null || lastInstance.snapshot == null) {
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -07003146 return;
3147 }
3148
3149 ImageView crossFadeHelper = new ImageView(this);
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08003150 crossFadeHelper.setImageBitmap(lastInstance.snapshot);
Schneider Victor-tulias25ecae12020-09-14 14:07:38 -07003151 crossFadeHelper.setImportantForAccessibility(IMPORTANT_FOR_ACCESSIBILITY_NO);
3152
3153 InsettableFrameLayout.LayoutParams layoutParams = new InsettableFrameLayout.LayoutParams(
3154 InsettableFrameLayout.LayoutParams.MATCH_PARENT,
3155 InsettableFrameLayout.LayoutParams.MATCH_PARENT);
3156
3157 layoutParams.ignoreInsets = true;
3158
3159 crossFadeHelper.setLayoutParams(layoutParams);
3160
3161 getRootView().addView(crossFadeHelper);
3162
3163 crossFadeHelper
3164 .animate()
3165 .setDuration(THEME_CROSS_FADE_ANIMATION_DURATION)
3166 .alpha(0f)
3167 .withEndAction(() -> getRootView().removeView(crossFadeHelper))
3168 .start();
3169 }
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08003170
Sunny Goyalb65d7662021-03-07 15:09:11 -08003171 public boolean supportsAdaptiveIconAnimation(View clickedView) {
3172 return false;
3173 }
3174
Tony Wickham39938cb2021-02-26 09:15:31 -08003175 public DragOptions getDefaultWorkspaceDragOptions() {
3176 return new DragOptions();
3177 }
3178
Sunny Goyal6c0c61a2020-12-08 19:19:56 -08003179 private static class NonConfigInstance {
3180 public Configuration config;
3181 public Bitmap snapshot;
3182 }
thiruramc96873c2021-02-11 15:13:47 -08003183
3184 @Override
3185 public StatsLogManager getStatsLogManager() {
3186 return super.getStatsLogManager().withDefaultInstanceId(mAllAppsSessionLogId);
3187 }
Brian Isganitis149dbcb2021-11-08 18:12:38 -05003188
3189 /**
3190 * Returns the current popup for testing, if any.
3191 */
3192 @VisibleForTesting
3193 @Nullable
3194 public ArrowPopup<?> getOptionsPopup() {
3195 return findViewById(R.id.popup_container);
3196 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003197}