blob: 25995dd1a35d17603f75f86db044edaf5bf660e0 [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 Goyal28c6b962015-10-12 11:42:05 -070019import android.Manifest;
Gilles Debunnedd6c9922010-10-25 11:23:41 -070020import android.animation.Animator;
Gilles Debunnedd6c9922010-10-25 11:23:41 -070021import android.animation.AnimatorSet;
Gilles Debunnedd6c9922010-10-25 11:23:41 -070022import android.animation.ValueAnimator;
Sunny Goyal70660032015-05-14 00:07:08 -070023import android.annotation.SuppressLint;
Adam Cohen0b395352014-06-09 22:54:36 +000024import android.annotation.TargetApi;
Winson Chungc7450e32012-04-17 17:34:08 -070025import android.app.ActivityOptions;
Chris Wren40c5ed32014-06-24 18:24:23 -040026import android.app.AlertDialog;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080027import android.app.SearchManager;
Adam Cohen0cf2a7c2011-11-08 15:07:01 -080028import android.appwidget.AppWidgetHostView;
Michael Jurkaaf442092010-06-10 17:01:57 -070029import android.appwidget.AppWidgetManager;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080030import android.content.ActivityNotFoundException;
Joe Onorato2ca0ae72009-11-10 13:14:13 -080031import android.content.BroadcastReceiver;
Michael Jurkae326f182011-11-21 14:05:46 -080032import android.content.ComponentCallbacks2;
Daniel Sandlerc9b18772010-04-22 14:37:59 -040033import android.content.ComponentName;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080034import android.content.Context;
Andrew Sappersteinabef55a2016-06-19 12:49:00 -070035import android.content.ContextWrapper;
Chris Wren40c5ed32014-06-24 18:24:23 -040036import android.content.DialogInterface;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080037import android.content.Intent;
Winson Chungf0ea4d32011-06-06 14:27:16 -070038import android.content.IntentFilter;
Adam Cohen173f7112015-03-27 15:14:00 -070039import android.content.IntentSender;
Winson Chung82f55532011-08-09 14:14:23 -070040import android.content.SharedPreferences;
Sunny Goyal745bad92016-05-02 10:54:12 -070041import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
Winson Chungaafa03c2010-06-11 17:34:16 -070042import android.content.pm.ActivityInfo;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080043import android.content.pm.PackageManager;
Adam Cohen3f9c9712014-10-31 11:48:25 -070044import android.database.sqlite.SQLiteDatabase;
Jon Mirandacc42c5b2016-10-27 17:15:27 -070045import android.graphics.Point;
Michael Jurkaaf442092010-06-10 17:01:57 -070046import android.graphics.Rect;
Michael Jurkaaf442092010-06-10 17:01:57 -070047import android.graphics.drawable.Drawable;
Brad Fitzpatrick319226a2010-09-01 13:45:16 -070048import android.os.AsyncTask;
Adam Cohen0f668f32014-09-08 19:54:17 +020049import android.os.Build;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080050import android.os.Bundle;
Jeff Sharkey1e2efc82009-11-06 15:17:59 -080051import android.os.Handler;
Sunny Goyal7c74e4a2016-12-15 15:53:17 -080052import android.os.Process;
Winson Chunga2413752012-04-03 14:22:34 -070053import android.os.StrictMode;
Daniel Sandler843e8602010-06-07 14:59:01 -040054import android.os.SystemClock;
Sunny Goyale26d1002016-06-20 14:52:14 -070055import android.os.Trace;
Sunny Goyala1d1bf32015-06-26 13:24:53 -070056import android.os.UserHandle;
Tony Wickham86222d22017-03-29 15:30:43 -070057import android.support.annotation.Nullable;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080058import android.text.Selection;
59import android.text.SpannableStringBuilder;
Michael Jurkaa33411c2012-06-14 16:18:21 -070060import android.text.TextUtils;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080061import android.text.method.TextKeyListener;
Joe Onorato7c312c12009-08-13 21:36:53 -070062import android.util.Log;
Adam Cohen96d30a12013-07-16 18:13:21 -070063import android.view.Display;
Adam Cohen96d30a12013-07-16 18:13:21 -070064import android.view.HapticFeedbackConstants;
65import android.view.KeyEvent;
Sunny Goyal66b24572016-09-21 15:57:55 -070066import android.view.KeyboardShortcutGroup;
67import android.view.KeyboardShortcutInfo;
Sunny Goyal9b29ca52017-02-17 10:39:44 -080068import android.view.LayoutInflater;
Adam Cohen96d30a12013-07-16 18:13:21 -070069import android.view.Menu;
Adam Cohen96d30a12013-07-16 18:13:21 -070070import android.view.MotionEvent;
Adam Cohen96d30a12013-07-16 18:13:21 -070071import android.view.View;
Adam Cohen0cf2a7c2011-11-08 15:07:01 -080072import android.view.View.OnLongClickListener;
Adam Cohen96d30a12013-07-16 18:13:21 -070073import android.view.ViewGroup;
74import android.view.ViewTreeObserver;
Mario Bertschleracbf5702017-03-03 10:58:06 -080075import android.view.WindowManager;
Svetoslav Ganov815ba2d2011-01-07 14:55:17 -080076import android.view.accessibility.AccessibilityEvent;
Tony Wickhame2217252016-03-22 16:34:23 -070077import android.view.accessibility.AccessibilityManager;
Sunny Goyal5a1f53b2015-05-27 10:24:24 -070078import android.view.animation.OvershootInterpolator;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080079import android.view.inputmethod.InputMethodManager;
Chet Haasea8f996d2015-02-17 12:56:04 -080080import android.widget.TextView;
Adam Cohen96d30a12013-07-16 18:13:21 -070081import android.widget.Toast;
Sunny Goyala1d1bf32015-06-26 13:24:53 -070082
Sunny Goyal651077b2014-06-30 14:15:31 -070083import com.android.launcher3.DropTarget.DragObject;
Sunny Goyala7ce1662016-05-31 15:01:35 -070084import com.android.launcher3.LauncherSettings.Favorites;
Sunny Goyalae502842016-06-17 08:43:56 -070085import com.android.launcher3.accessibility.LauncherAccessibilityDelegate;
Winson Chung5f4e0fd2015-05-22 11:12:27 -070086import com.android.launcher3.allapps.AllAppsContainerView;
Hyunyoung Song645764e2016-06-06 14:19:02 -070087import com.android.launcher3.allapps.AllAppsTransitionController;
Sunny Goyalb5e65c82016-10-26 18:32:38 -070088import com.android.launcher3.anim.AnimationLayerSet;
Sunny Goyalffe83f12014-08-14 17:39:34 -070089import com.android.launcher3.compat.AppWidgetManagerCompat;
Kenny Guyed131872014-04-30 03:02:21 +010090import com.android.launcher3.compat.LauncherAppsCompat;
Sunny Goyal782f0c92017-01-19 10:27:54 -080091import com.android.launcher3.compat.PinItemRequestCompat;
Tony Wickhame0c33232016-02-08 11:37:04 -080092import com.android.launcher3.config.FeatureFlags;
Vadim Tryshevfedca432015-08-19 17:55:02 -070093import com.android.launcher3.dragndrop.DragController;
94import com.android.launcher3.dragndrop.DragLayer;
Sunny Goyal94b510c2016-08-16 15:36:48 -070095import com.android.launcher3.dragndrop.DragOptions;
Vadim Tryshevfedca432015-08-19 17:55:02 -070096import com.android.launcher3.dragndrop.DragView;
Sunny Goyalb38fab72017-01-20 19:32:31 -080097import com.android.launcher3.dragndrop.PinItemDragListener;
Tony Wickham827cef22016-03-17 15:39:39 -070098import com.android.launcher3.dynamicui.ExtractedColors;
Sunny Goyal26119432016-02-18 22:09:23 +000099import com.android.launcher3.folder.Folder;
100import com.android.launcher3.folder.FolderIcon;
Sunny Goyal66b24572016-09-21 15:57:55 -0700101import com.android.launcher3.keyboard.CustomActionsPopup;
Sunny Goyal3333b0c2016-05-09 20:43:21 -0700102import com.android.launcher3.keyboard.ViewGroupFocusHelper;
Sunny Goyala7ce1662016-05-31 15:01:35 -0700103import com.android.launcher3.logging.FileLog;
Hyunyoung Songaa953652016-04-19 18:30:24 -0700104import com.android.launcher3.logging.UserEventDispatcher;
Sunny Goyala535ae42017-02-27 10:07:13 -0800105import com.android.launcher3.model.ModelWriter;
Sunny Goyald164b7f2016-10-12 20:49:31 -0700106import com.android.launcher3.model.PackageItemInfo;
107import com.android.launcher3.model.WidgetItem;
Sunny Goyala535ae42017-02-27 10:07:13 -0800108import com.android.launcher3.notification.NotificationListener;
Hyunyoung Song7d2fc812016-06-15 12:51:30 -0700109import com.android.launcher3.pageindicators.PageIndicator;
Tony Wickham540913e2017-01-23 11:47:51 -0800110import com.android.launcher3.popup.PopupContainerWithArrow;
Sunny Goyala535ae42017-02-27 10:07:13 -0800111import com.android.launcher3.popup.PopupDataProvider;
Tony Wickham1bce7fd2016-04-28 17:39:03 -0700112import com.android.launcher3.shortcuts.DeepShortcutManager;
Sunny Goyald3b87ef2016-07-28 12:11:54 -0700113import com.android.launcher3.shortcuts.ShortcutKey;
Jon Mirandac6cf4932017-02-07 17:12:36 -0800114import com.android.launcher3.userevent.nano.LauncherLogProto;
Sunny Goyal6c46a6d2016-11-23 02:24:32 +0530115import com.android.launcher3.userevent.nano.LauncherLogProto.Action;
116import com.android.launcher3.userevent.nano.LauncherLogProto.ContainerType;
117import com.android.launcher3.userevent.nano.LauncherLogProto.ControlType;
Sunny Goyal2100c782016-08-22 16:00:03 -0700118import com.android.launcher3.util.ActivityResultInfo;
Winson Chung6b1c73f2015-06-18 11:38:42 -0700119import com.android.launcher3.util.ComponentKey;
Sunny Goyald3b87ef2016-07-28 12:11:54 -0700120import com.android.launcher3.util.ItemInfoMatcher;
Tony Wickhambfbf7f92016-05-19 11:19:39 -0700121import com.android.launcher3.util.MultiHashMap;
Sunny Goyal04cc3a72016-05-17 10:32:43 -0700122import com.android.launcher3.util.PackageManagerHelper;
Tony Wickham010d2552017-01-20 08:15:28 -0800123import com.android.launcher3.util.PackageUserKey;
Sunny Goyal2100c782016-08-22 16:00:03 -0700124import com.android.launcher3.util.PendingRequestArgs;
Sunny Goyal322d5562015-06-25 19:35:49 -0700125import com.android.launcher3.util.TestingUtils;
Adam Cohen091440a2015-03-18 14:16:05 -0700126import com.android.launcher3.util.Thunk;
Sunny Goyal527c7d32015-08-28 15:19:36 -0700127import com.android.launcher3.util.ViewOnDrawExecutor;
Sunny Goyal782f0c92017-01-19 10:27:54 -0800128import com.android.launcher3.widget.PendingAddShortcutInfo;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700129import com.android.launcher3.widget.PendingAddWidgetInfo;
Sunny Goyal04a324a2017-01-20 21:08:59 -0800130import com.android.launcher3.widget.WidgetAddFlowHandler;
Hyunyoung Songb99ff3e2015-04-23 15:17:50 -0700131import com.android.launcher3.widget.WidgetHostViewLoader;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700132import com.android.launcher3.widget.WidgetsContainerView;
Adam Cohen6c5891a2014-07-09 23:53:15 -0700133
Adam Cohen16d7ffc2011-10-05 17:49:14 -0700134import java.io.FileDescriptor;
Adam Cohen16d7ffc2011-10-05 17:49:14 -0700135import java.io.PrintWriter;
Adam Cohenc0dcf592011-06-01 15:30:43 -0700136import java.util.ArrayList;
Winson Chungf0c6ae02012-03-21 16:10:31 -0700137import java.util.Collection;
Adam Cohenc0dcf592011-06-01 15:30:43 -0700138import java.util.HashMap;
Sunny Goyal4390ace2014-10-13 11:33:11 -0700139import java.util.HashSet;
Michael Jurkad7c28052012-04-27 15:43:36 -0700140import java.util.List;
Tony Wickham010d2552017-01-20 08:15:28 -0800141import java.util.Set;
Adam Cohenc0dcf592011-06-01 15:30:43 -0700142
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800143/**
144 * Default launcher application.
145 */
Sunny Goyal27835952017-01-13 12:15:53 -0800146public class Launcher extends BaseActivity
Adam Cohen79d90c52016-04-22 13:29:20 -0700147 implements LauncherExterns, View.OnClickListener, OnLongClickListener,
148 LauncherModel.Callbacks, View.OnTouchListener, LauncherProviderChangeListener,
Tony Wickhame2217252016-03-22 16:34:23 -0700149 AccessibilityManager.AccessibilityStateChangeListener {
Vadim Tryshevfedca432015-08-19 17:55:02 -0700150 public static final String TAG = "Launcher";
Sunny Goyal2bba4c32015-05-18 15:42:48 -0700151 static final boolean LOGD = false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800152
Sunny Goyalc84e6e12015-10-02 12:48:37 -0700153 static final boolean DEBUG_WIDGETS = false;
Winson Chunga2413752012-04-03 14:22:34 -0700154 static final boolean DEBUG_STRICT_MODE = false;
Daniel Sandlerf061f822013-06-27 13:59:36 -0400155 static final boolean DEBUG_RESUME_TIME = false;
Romain Guy6fefcf12009-06-11 13:07:43 -0700156
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800157 private static final int REQUEST_CREATE_SHORTCUT = 1;
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700158 private static final int REQUEST_CREATE_APPWIDGET = 5;
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700159 private static final int REQUEST_PICK_APPWIDGET = 9;
Mike Clerona0618e42009-10-22 13:55:21 -0700160 private static final int REQUEST_PICK_WALLPAPER = 10;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800161
Michael Jurka8b805b12012-04-18 14:23:14 -0700162 private static final int REQUEST_BIND_APPWIDGET = 11;
Sunny Goyald478c832016-04-01 12:04:16 -0700163 private static final int REQUEST_BIND_PENDING_APPWIDGET = 14;
Sunny Goyalff572272014-07-23 13:58:07 -0700164 private static final int REQUEST_RECONFIGURE_APPWIDGET = 12;
Michael Jurka8b805b12012-04-18 14:23:14 -0700165
Sunny Goyal28c6b962015-10-12 11:42:05 -0700166 private static final int REQUEST_PERMISSION_CALL_PHONE = 13;
167
Sunny Goyal5a1f53b2015-05-27 10:24:24 -0700168 private static final float BOUNCE_ANIMATION_TENSION = 1.3f;
169
Mathew Inwood876a8462013-06-14 14:12:41 +0100170 /**
171 * IntentStarter uses request codes starting with this. This must be greater than all activity
172 * request codes used internally.
173 */
174 protected static final int REQUEST_LAST = 100;
175
Mario Bertschleracbf5702017-03-03 10:58:06 -0800176 private static final int SOFT_INPUT_MODE_DEFAULT =
Jon Mirandafd516322017-03-09 13:14:50 -0800177 WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN;
Mario Bertschleracbf5702017-03-03 10:58:06 -0800178 private static final int SOFT_INPUT_MODE_ALL_APPS =
Jon Mirandafd516322017-03-09 13:14:50 -0800179 WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE;
Mario Bertschleracbf5702017-03-03 10:58:06 -0800180
Winson Chung2672ff92012-05-04 16:22:30 -0700181 // The Intent extra that defines whether to ignore the launch animation
182 static final String INTENT_EXTRA_IGNORE_LAUNCH_ANIMATION =
Daniel Sandler325dc232013-06-05 22:57:57 -0400183 "com.android.launcher3.intent.extra.shortcut.INGORE_LAUNCH_ANIMATION";
Winson Chung2672ff92012-05-04 16:22:30 -0700184
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800185 // Type: int
186 private static final String RUNTIME_STATE_CURRENT_SCREEN = "launcher.current_screen";
Michael Jurka883f55b2010-10-21 15:47:14 -0700187 // Type: int
188 private static final String RUNTIME_STATE = "launcher.state";
Sunny Goyal2100c782016-08-22 16:00:03 -0700189 // Type: PendingRequestArgs
190 private static final String RUNTIME_STATE_PENDING_REQUEST_ARGS = "launcher.request_args";
191 // Type: ActivityResultInfo
192 private static final String RUNTIME_STATE_PENDING_ACTIVITY_RESULT = "launcher.activity_result";
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800193
Hyunyoung Songc001cf52016-07-21 17:32:43 -0700194 static final String APPS_VIEW_SHOWN = "launcher.apps_view_shown";
Adam Cohenb54a5982014-01-08 15:21:04 -0800195
Patrick Dubroy6b509c12010-08-23 15:08:16 -0700196 /** The different states that Launcher can be in. */
Tony Wickham94e0d372015-09-11 12:17:48 -0700197 enum State { NONE, WORKSPACE, WORKSPACE_SPRING_LOADED, APPS, APPS_SPRING_LOADED,
198 WIDGETS, WIDGETS_SPRING_LOADED }
Rahul Chaturvedi7fc77ca2015-05-19 18:02:16 -0700199
Adam Cohen091440a2015-03-18 14:16:05 -0700200 @Thunk State mState = State.WORKSPACE;
Adam Cohen091440a2015-03-18 14:16:05 -0700201 @Thunk LauncherStateTransitionAnimation mStateTransitionAnimation;
Patrick Dubroy6b509c12010-08-23 15:08:16 -0700202
Sunny Goyalc5c60ad2014-07-14 12:02:01 -0700203 private boolean mIsSafeModeEnabled;
204
Sunny Goyal27835952017-01-13 12:15:53 -0800205 public static final int APPWIDGET_HOST_ID = 1024;
Adam Cohen4f8071b2016-02-13 16:06:05 -0800206 public static final int EXIT_SPRINGLOADED_MODE_SHORT_TIMEOUT = 500;
Adam Cohenad4e15c2013-10-17 16:21:35 -0700207 private static final int ON_ACTIVITY_RESULT_ANIMATION_DELAY = 500;
Adam Cohen646fdf72014-04-08 16:59:36 -0700208 private static final int ACTIVITY_START_DELAY = 1000;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800209
Winson Chunga2413752012-04-03 14:22:34 -0700210 // How long to wait before the new-shortcut animation automatically pans the workspace
Winson Chung94d67682013-09-25 16:29:40 -0700211 private static int NEW_APPS_PAGE_MOVE_DELAY = 500;
212 private static int NEW_APPS_ANIMATION_INACTIVE_TIMEOUT_SECONDS = 5;
Adam Cohen091440a2015-03-18 14:16:05 -0700213 @Thunk static int NEW_APPS_ANIMATION_DELAY = 500;
Winson Chunga2413752012-04-03 14:22:34 -0700214
Sunny Goyal60820d72017-05-09 12:40:11 -0700215 private final ExtractedColors mExtractedColors = new ExtractedColors();
216
Adam Cohen091440a2015-03-18 14:16:05 -0700217 @Thunk Workspace mWorkspace;
Craig Mautner360310b2012-10-26 15:13:08 -0700218 private View mLauncherView;
Adam Cohen091440a2015-03-18 14:16:05 -0700219 @Thunk DragLayer mDragLayer;
Michael Jurkab737ee62011-11-15 15:57:22 -0800220 private DragController mDragController;
Sunny Goyal6178f132016-07-11 17:30:03 -0700221 private View mQsbContainer;
Sunny Goyal322d5562015-06-25 19:35:49 -0700222
223 public View mWeightWatcher;
Romain Guycbb89e42009-06-08 15:52:54 -0700224
Sunny Goyalffe83f12014-08-14 17:39:34 -0700225 private AppWidgetManagerCompat mAppWidgetManager;
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700226 private LauncherAppWidgetHost mAppWidgetHost;
Romain Guycbb89e42009-06-08 15:52:54 -0700227
Michael Jurka0280c3b2010-09-17 15:00:07 -0700228 private int[] mTmpAddItemCellCoordinates = new int[2];
229
Sunny Goyal316490e2015-06-02 09:38:28 -0700230 @Thunk Hotseat mHotseat;
Jorim Jaggid017f882014-01-14 17:08:48 -0800231 private ViewGroup mOverviewPanel;
Adam Cohenf358a4b2013-07-23 16:47:31 -0700232
Michael Jurka838a4ca2011-02-07 13:33:06 -0800233 private View mAllAppsButton;
Hyunyoung Song98ff38a2015-07-10 17:50:13 -0700234 private View mWidgetsButton;
Winson Chung3d503fb2011-07-13 17:25:49 -0700235
Sunny Goyal47328fd2016-05-25 18:56:41 -0700236 private DropTargetBar mDropTargetBar;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700237
238 // Main container view for the all apps screen.
Winson Chung5f4e0fd2015-05-22 11:12:27 -0700239 @Thunk AllAppsContainerView mAppsView;
Hyunyoung Song645764e2016-06-06 14:19:02 -0700240 AllAppsTransitionController mAllAppsController;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700241
Hyunyoung Song2bd3d7d2015-05-21 13:04:53 -0700242 // Main container view and the model for the widget tray screen.
243 @Thunk WidgetsContainerView mWidgetsView;
Sunny Goyald164b7f2016-10-12 20:49:31 -0700244 @Thunk MultiHashMap<PackageItemInfo, WidgetItem> mAllWidgets;
Hyunyoung Song3f471442015-04-08 19:01:34 -0700245
Winson Chung4a2afa32012-07-19 14:53:05 -0700246 // We set the state in both onCreate and then onNewIntent in some cases, which causes both
247 // scroll issues (because the workspace may not have been measured yet) and extra work.
248 // Instead, just save the state that we need to restore Launcher to, and commit it in onResume.
249 private State mOnResumeState = State.NONE;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800250
251 private SpannableStringBuilder mDefaultKeySsb = null;
252
Adam Cohen091440a2015-03-18 14:16:05 -0700253 @Thunk boolean mWorkspaceLoading = true;
Joe Onorato9c1289c2009-08-17 11:03:03 -0400254
Joe Onorato34a0e1b2009-12-14 17:44:51 -0800255 private boolean mPaused = true;
Joe Onoratoef2efcf2010-10-27 13:21:00 -0700256 private boolean mOnResumeNeedsLoad;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800257
Michael Jurka1e2f4652013-07-08 18:03:46 -0700258 private ArrayList<Runnable> mBindOnResumeCallbacks = new ArrayList<Runnable>();
Michael Jurka7607c2f2013-04-03 14:33:19 -0700259 private ArrayList<Runnable> mOnResumeCallbacks = new ArrayList<Runnable>();
Sunny Goyal527c7d32015-08-28 15:19:36 -0700260 private ViewOnDrawExecutor mPendingExecutor;
Michael Jurka7607c2f2013-04-03 14:33:19 -0700261
Joe Onorato9c1289c2009-08-17 11:03:03 -0400262 private LauncherModel mModel;
Sunny Goyal43bf11d2017-02-02 13:52:53 -0800263 private ModelWriter mModelWriter;
Joe Onorato0589f0f2010-02-08 13:44:00 -0800264 private IconCache mIconCache;
Sunny Goyalae502842016-06-17 08:43:56 -0700265 private LauncherAccessibilityDelegate mAccessibilityDelegate;
Sunny Goyal1acc56a2016-09-25 21:23:25 -0700266 private Handler mHandler = new Handler();
Hyunyoung Songc001cf52016-07-21 17:32:43 -0700267 private boolean mIsResumeFromActionScreenOff;
Sunny Goyal1acc56a2016-09-25 21:23:25 -0700268 private boolean mHasFocus = false;
269 private boolean mAttached = false;
Joe Onorato9c1289c2009-08-17 11:03:03 -0400270
Tony Wickham010d2552017-01-20 08:15:28 -0800271 private PopupDataProvider mPopupDataProvider;
Tony Wickhambfbf7f92016-05-19 11:19:39 -0700272
Adam Cohen61f560d2013-09-30 15:58:20 -0700273 private View.OnTouchListener mHapticFeedbackTouchListener;
274
Winson Chung400438b2011-01-16 17:53:48 -0800275 // Determines how long to wait after a rotation before restoring the screen orientation to
276 // match the sensor state.
Sunny Goyal756cd262015-08-20 12:33:21 -0700277 private static final int RESTORE_SCREEN_ORIENTATION_DELAY = 500;
Winson Chung400438b2011-01-16 17:53:48 -0800278
Adam Cohen1462de32012-07-24 22:34:36 -0700279 private final ArrayList<Integer> mSynchronouslyBoundPages = new ArrayList<Integer>();
280
Winson Chung46353de2012-02-16 14:05:10 -0800281 // We only want to get the SharedPreferences once since it does an FS stat each time we get
282 // it from the context.
283 private SharedPreferences mSharedPrefs;
284
Adam Cohen4b66bf32015-09-18 12:15:19 -0700285 private boolean mMoveToDefaultScreenFromNewIntent;
286
Winson Chung13eb5272015-05-11 16:30:13 -0700287 // This is set to the view that launched the activity that navigated the user away from
288 // launcher. Since there is no callback for when the activity has finished launching, enable
289 // the press state and keep this reference to reset the press state when we return to launcher.
Michael Jurkaddd62e92011-02-16 17:49:14 -0800290 private BubbleTextView mWaitingForResume;
291
Adam Cohen59400422014-03-05 18:07:04 -0800292 protected static HashMap<String, CustomAppWidget> sCustomAppWidgets =
293 new HashMap<String, CustomAppWidget>();
294
Adam Cohen59400422014-03-05 18:07:04 -0800295 static {
Sunny Goyal322d5562015-06-25 19:35:49 -0700296 if (TestingUtils.ENABLE_CUSTOM_WIDGET_TEST) {
297 TestingUtils.addDummyWidget(sCustomAppWidgets);
Adam Cohen59400422014-03-05 18:07:04 -0800298 }
299 }
300
Hyunyoung Song06ca7562016-07-29 13:03:54 -0700301 // Exiting spring loaded mode happens with a delay. This runnable object triggers the
302 // state transition. If another state transition happened during this delay,
303 // simply unregister this runnable.
304 private Runnable mExitSpringLoadedModeRunnable;
305
Adam Cohen091440a2015-03-18 14:16:05 -0700306 @Thunk Runnable mBuildLayersRunnable = new Runnable() {
Michael Jurkac1f5d262011-09-30 19:32:27 -0700307 public void run() {
Michael Jurka9d906c72011-10-14 06:25:36 -0700308 if (mWorkspace != null) {
309 mWorkspace.buildPageHardwareLayers();
310 }
Michael Jurkac1f5d262011-09-30 19:32:27 -0700311 }
312 };
313
Sunny Goyal2100c782016-08-22 16:00:03 -0700314 // Activity result which needs to be processed after workspace has loaded.
315 private ActivityResultInfo mPendingActivityResult;
316 /**
317 * Holds extra information required to handle a result from an external call, like
318 * {@link #startActivityForResult(Intent, int)} or {@link #requestPermissions(String[], int)}
319 */
320 private PendingRequestArgs mPendingRequestArgs;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800321
Jon Miranda379198e2016-09-23 08:54:40 -0700322 private float mLastDispatchTouchEventX = 0.0f;
Jon Miranda379198e2016-09-23 08:54:40 -0700323
Sunny Goyal3333b0c2016-05-09 20:43:21 -0700324 public ViewGroupFocusHelper mFocusHandler;
Sunny Goyal7779d622015-06-11 16:18:39 -0700325 private boolean mRotationEnabled = false;
Rahul Chaturvedi799aa042015-06-01 21:26:41 -0400326
327 @Thunk void setOrientation() {
328 if (mRotationEnabled) {
329 unlockScreenOrientation(true);
330 } else {
331 setRequestedOrientation(
332 ActivityInfo.SCREEN_ORIENTATION_NOSENSOR);
Rahul Chaturvedi7fc77ca2015-05-19 18:02:16 -0700333 }
Rahul Chaturvedi799aa042015-06-01 21:26:41 -0400334 }
Rahul Chaturvedi7fc77ca2015-05-19 18:02:16 -0700335
Sunny Goyal745bad92016-05-02 10:54:12 -0700336 private RotationPrefChangeHandler mRotationPrefChangeHandler;
Sunny Goyal7779d622015-06-11 16:18:39 -0700337
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800338 @Override
339 protected void onCreate(Bundle savedInstanceState) {
Winson Chunga2413752012-04-03 14:22:34 -0700340 if (DEBUG_STRICT_MODE) {
341 StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
342 .detectDiskReads()
343 .detectDiskWrites()
344 .detectNetwork() // or .detectAll() for all detectable problems
345 .penaltyLog()
346 .build());
347 StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
348 .detectLeakedSqlLiteObjects()
349 .detectLeakedClosableObjects()
350 .penaltyLog()
351 .penaltyDeath()
352 .build());
353 }
Sunny Goyale26d1002016-06-20 14:52:14 -0700354 if (LauncherAppState.PROFILE_STARTUP) {
355 Trace.beginSection("Launcher-onCreate");
356 }
Winson Chunga2413752012-04-03 14:22:34 -0700357
Adam Cohen9211d422014-10-07 18:14:53 -0700358 if (mLauncherCallbacks != null) {
359 mLauncherCallbacks.preOnCreate();
360 }
361
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800362 super.onCreate(savedInstanceState);
Daniel Sandlere060b0b2013-06-27 21:47:55 -0400363
Sunny Goyal87f784c2017-01-11 10:48:34 -0800364 LauncherAppState app = LauncherAppState.getInstance(this);
Winson Chung6e1c0d32013-10-25 15:24:24 -0700365
Adam Cohen2e6da152015-05-06 11:42:25 -0700366 // Load configuration-specific DeviceProfile
Sunny Goyal27835952017-01-13 12:15:53 -0800367 mDeviceProfile = app.getInvariantDeviceProfile().getDeviceProfile(this);
Jon Mirandafe964322017-03-22 10:25:17 -0700368 if (isInMultiWindowModeCompat()) {
Jon Mirandacc42c5b2016-10-27 17:15:27 -0700369 Display display = getWindowManager().getDefaultDisplay();
370 Point mwSize = new Point();
371 display.getSize(mwSize);
372 mDeviceProfile = mDeviceProfile.getMultiWindowProfile(this, mwSize);
373 }
Sunny Goyalc6205602015-05-21 20:46:33 -0700374
Sunny Goyalf7258242015-10-19 16:59:07 -0700375 mSharedPrefs = Utilities.getPrefs(this);
Sunny Goyalc5c60ad2014-07-14 12:02:01 -0700376 mIsSafeModeEnabled = getPackageManager().isSafeMode();
Joe Onorato0589f0f2010-02-08 13:44:00 -0800377 mModel = app.setLauncher(this);
Sunny Goyal43bf11d2017-02-02 13:52:53 -0800378 mModelWriter = mModel.getWriter(mDeviceProfile.isVerticalBarLayout());
Joe Onorato0589f0f2010-02-08 13:44:00 -0800379 mIconCache = app.getIconCache();
Sunny Goyalae502842016-06-17 08:43:56 -0700380 mAccessibilityDelegate = new LauncherAccessibilityDelegate(this);
Adam Cohen2e6da152015-05-06 11:42:25 -0700381
Joe Onorato41a12d22009-10-31 18:30:00 -0400382 mDragController = new DragController(this);
Hyunyoung Song645764e2016-06-06 14:19:02 -0700383 mAllAppsController = new AllAppsTransitionController(this);
384 mStateTransitionAnimation = new LauncherStateTransitionAnimation(this, mAllAppsController);
Romain Guycbb89e42009-06-08 15:52:54 -0700385
Sunny Goyalffe83f12014-08-14 17:39:34 -0700386 mAppWidgetManager = AppWidgetManagerCompat.getInstance(this);
Adam Cohen53805212013-10-01 10:39:23 -0700387
The Android Open Source Project7376fae2009-03-11 12:11:58 -0700388 mAppWidgetHost = new LauncherAppWidgetHost(this, APPWIDGET_HOST_ID);
389 mAppWidgetHost.startListening();
Romain Guycbb89e42009-06-08 15:52:54 -0700390
Winson Chungb8b2a5a2012-07-12 17:55:31 -0700391 // If we are getting an onCreate, we can actually preempt onResume and unset mPaused here,
392 // this also ensures that any synchronous binding below doesn't re-trigger another
393 // LauncherModel load.
394 mPaused = false;
395
Sunny Goyal60820d72017-05-09 12:40:11 -0700396 mLauncherView = LayoutInflater.from(this).inflate(R.layout.launcher, null);
Michael Jurka7267fa52013-09-26 15:29:57 -0700397
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800398 setupViews();
Winson1f064272016-07-18 17:18:02 -0700399 mDeviceProfile.layout(this, false /* notifyListeners */);
Tony Wickham827cef22016-03-17 15:39:39 -0700400 loadExtractedColorsAndColorItems();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800401
Tony Wickham010d2552017-01-20 08:15:28 -0800402 mPopupDataProvider = new PopupDataProvider(this);
403
Tony Wickhame2217252016-03-22 16:34:23 -0700404 ((AccessibilityManager) getSystemService(ACCESSIBILITY_SERVICE))
405 .addAccessibilityStateChangeListener(this);
406
Joe Onorato7c312c12009-08-13 21:36:53 -0700407 lockAllApps();
Joe Onorato7404ee42009-07-31 11:54:44 -0700408
Sunny Goyalfe770c92016-09-27 14:38:58 -0700409 restoreState(savedInstanceState);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800410
Sunny Goyale26d1002016-06-20 14:52:14 -0700411 if (LauncherAppState.PROFILE_STARTUP) {
412 Trace.endSection();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800413 }
414
Sunny Goyal2100c782016-08-22 16:00:03 -0700415 // We only load the page synchronously if the user rotates (or triggers a
416 // configuration change) while launcher is in the foreground
Sunny Goyalfe770c92016-09-27 14:38:58 -0700417 int currentScreen = PagedView.INVALID_RESTORE_PAGE;
418 if (savedInstanceState != null) {
419 currentScreen = savedInstanceState.getInt(RUNTIME_STATE_CURRENT_SCREEN, currentScreen);
420 }
421 if (!mModel.startLoader(currentScreen)) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700422 // If we are not binding synchronously, show a fade in animation when
423 // the first page bind completes.
424 mDragLayer.setAlpha(0);
425 } else {
Sunny Goyalfe770c92016-09-27 14:38:58 -0700426 // Pages bound synchronously.
427 mWorkspace.setCurrentPage(currentScreen);
428
Sunny Goyal2100c782016-08-22 16:00:03 -0700429 setWorkspaceLoading(true);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800430 }
431
432 // For handling default keys
433 mDefaultKeySsb = new SpannableStringBuilder();
434 Selection.setSelection(mDefaultKeySsb, 0);
Joe Onorato34a0e1b2009-12-14 17:44:51 -0800435
Sunny Goyal8f3819b2016-02-23 14:49:22 -0800436 mRotationEnabled = getResources().getBoolean(R.bool.allow_rotation);
Rahul Chaturvedi7fc77ca2015-05-19 18:02:16 -0700437 // In case we are on a device with locked rotation, we should look at preferences to check
438 // if the user has specifically allowed rotation.
439 if (!mRotationEnabled) {
Sunny Goyal21bf5312015-08-21 11:08:24 -0700440 mRotationEnabled = Utilities.isAllowRotationPrefEnabled(getApplicationContext());
Sunny Goyal745bad92016-05-02 10:54:12 -0700441 mRotationPrefChangeHandler = new RotationPrefChangeHandler();
442 mSharedPrefs.registerOnSharedPreferenceChangeListener(mRotationPrefChangeHandler);
Rahul Chaturvedi7fc77ca2015-05-19 18:02:16 -0700443 }
444
Sunny Goyal5a81c382017-03-20 15:08:06 -0700445 if (PinItemDragListener.handleDragRequest(this, getIntent())) {
446 // Temporarily enable the rotation
447 mRotationEnabled = true;
448 }
449
Rahul Chaturvedi7fc77ca2015-05-19 18:02:16 -0700450 // On large interfaces, or on devices that a user has specifically enabled screen rotation,
451 // we want the screen to auto-rotate based on the current orientation
Rahul Chaturvedi799aa042015-06-01 21:26:41 -0400452 setOrientation();
Winson Chungaf40f202013-09-18 18:26:31 -0700453
Sunny Goyal0bbd5542016-11-11 10:41:26 -0800454 setContentView(mLauncherView);
Adam Cohen9211d422014-10-07 18:14:53 -0700455 if (mLauncherCallbacks != null) {
456 mLauncherCallbacks.onCreate(savedInstanceState);
457 }
458 }
459
Sunny Goyal7779d622015-06-11 16:18:39 -0700460 @Override
Sunny Goyal0bbd5542016-11-11 10:41:26 -0800461 public View findViewById(int id) {
462 return mLauncherView.findViewById(id);
463 }
464
465 @Override
Tony Wickham827cef22016-03-17 15:39:39 -0700466 public void onExtractedColorsChanged() {
467 loadExtractedColorsAndColorItems();
Sunny Goyal60820d72017-05-09 12:40:11 -0700468 mExtractedColors.notifyChange();
Sunny Goyal5e7b2382017-04-25 23:09:06 -0700469 }
470
471 public ExtractedColors getExtractedColors() {
472 return mExtractedColors;
Tony Wickham827cef22016-03-17 15:39:39 -0700473 }
474
Sunny Goyal2e013ea2016-10-07 16:17:19 -0700475 @Override
476 public void onAppWidgetHostReset() {
477 if (mAppWidgetHost != null) {
478 mAppWidgetHost.startListening();
479 }
480 }
481
Tony Wickham827cef22016-03-17 15:39:39 -0700482 private void loadExtractedColorsAndColorItems() {
Tony Wickham462b5cc2016-04-01 16:00:49 -0700483 // TODO: do this in pre-N as well, once the extraction part is complete.
Sunny Goyalf5e37442016-11-02 10:31:24 -0700484 if (Utilities.ATLEAST_NOUGAT) {
Tony Wickham827cef22016-03-17 15:39:39 -0700485 mExtractedColors.load(this);
Tony Wickham462b5cc2016-04-01 16:00:49 -0700486 mHotseat.updateColor(mExtractedColors, !mPaused);
Sunny Goyald0a6ae72016-06-16 12:29:03 -0700487 mWorkspace.getPageIndicator().updateColor(mExtractedColors);
Sunny Goyal5e7b2382017-04-25 23:09:06 -0700488 boolean lightStatusBar = (FeatureFlags.LIGHT_STATUS_BAR &&
489 mExtractedColors.getColor(ExtractedColors.STATUS_BAR_INDEX) ==
490 ExtractedColors.DEFAULT_LIGHT);
Tony Wickham345bff32016-09-28 15:34:51 -0700491 // It's possible that All Apps is visible when this is run,
Hyunyoung Song3285da32016-12-19 14:46:21 -0800492 // so always use light status bar in that case. Only change nav bar color to status bar
493 // color when All Apps is visible.
Tony Wickhamed687282017-03-20 16:49:37 -0700494 activateLightSystemBars(lightStatusBar || isAllAppsVisible(), true, isAllAppsVisible());
Tony Wickham827cef22016-03-17 15:39:39 -0700495 }
496 }
497
Hyunyoung Songdf9f1472016-12-09 13:56:15 -0800498 // TODO: use platform flag on API >= 26
499 private static final int SYSTEM_UI_FLAG_LIGHT_NAV_BAR = 0x10;
500
Tony Wickham345bff32016-09-28 15:34:51 -0700501 /**
Tony Wickhamed687282017-03-20 16:49:37 -0700502 * Sets the status and/or nav bar to be light or not. Light status bar means dark icons.
503 * @param isLight make sure the system bar is light.
504 * @param statusBar if true, make the status bar theme match the isLight param.
505 * @param navBar if true, make the nav bar theme match the isLight param.
Tony Wickham345bff32016-09-28 15:34:51 -0700506 */
Tony Wickhamed687282017-03-20 16:49:37 -0700507 public void activateLightSystemBars(boolean isLight, boolean statusBar, boolean navBar) {
Tony Wickham345bff32016-09-28 15:34:51 -0700508 int oldSystemUiFlags = getWindow().getDecorView().getSystemUiVisibility();
509 int newSystemUiFlags = oldSystemUiFlags;
Tony Wickhamed687282017-03-20 16:49:37 -0700510 if (isLight) {
511 if (statusBar) {
512 newSystemUiFlags |= View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR;
513 }
514 if (navBar && Utilities.isAtLeastO()) {
Hyunyoung Song3285da32016-12-19 14:46:21 -0800515 newSystemUiFlags |= SYSTEM_UI_FLAG_LIGHT_NAV_BAR;
516 }
Tony Wickham93113872016-09-14 16:46:32 -0700517 } else {
Tony Wickhamed687282017-03-20 16:49:37 -0700518 if (statusBar) {
519 newSystemUiFlags &= ~(View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR);
520 }
521 if (navBar && Utilities.isAtLeastO()) {
Hyunyoung Songdf9f1472016-12-09 13:56:15 -0800522 newSystemUiFlags &= ~(SYSTEM_UI_FLAG_LIGHT_NAV_BAR);
523 }
524 }
Hyunyoung Song3285da32016-12-19 14:46:21 -0800525
Tony Wickham345bff32016-09-28 15:34:51 -0700526 if (newSystemUiFlags != oldSystemUiFlags) {
527 getWindow().getDecorView().setSystemUiVisibility(newSystemUiFlags);
528 }
Tony Wickham93113872016-09-14 16:46:32 -0700529 }
530
Adam Cohen9211d422014-10-07 18:14:53 -0700531 private LauncherCallbacks mLauncherCallbacks;
532
533 public void onPostCreate(Bundle savedInstanceState) {
534 super.onPostCreate(savedInstanceState);
535 if (mLauncherCallbacks != null) {
536 mLauncherCallbacks.onPostCreate(savedInstanceState);
537 }
538 }
539
Winson1f064272016-07-18 17:18:02 -0700540 public void onInsetsChanged(Rect insets) {
541 mDeviceProfile.updateInsets(insets);
542 mDeviceProfile.layout(this, true /* notifyListeners */);
543 }
544
Sunny Goyal32554d12015-12-03 15:31:25 -0800545 /**
546 * Call this after onCreate to set or clear overlay.
547 */
548 public void setLauncherOverlay(LauncherOverlay overlay) {
549 if (overlay != null) {
550 overlay.setOverlayCallbacks(new LauncherOverlayCallbacksImpl());
551 }
552 mWorkspace.setLauncherOverlay(overlay);
553 }
554
Adam Cohen9211d422014-10-07 18:14:53 -0700555 public boolean setLauncherCallbacks(LauncherCallbacks callbacks) {
556 mLauncherCallbacks = callbacks;
557 return true;
Adam Cohenf9426d52012-06-04 17:26:21 -0700558 }
559
Anjali Koppal67e7cae2014-03-13 12:14:12 -0700560 @Override
Sunny Goyal2e013ea2016-10-07 16:17:19 -0700561 public void onLauncherProviderChanged() {
Adam Cohen9211d422014-10-07 18:14:53 -0700562 if (mLauncherCallbacks != null) {
563 mLauncherCallbacks.onLauncherProviderChange();
564 }
565 }
Anjali Koppal67e7cae2014-03-13 12:14:12 -0700566
Adam Cohen9211d422014-10-07 18:14:53 -0700567 /** To be overridden by subclasses to hint to Launcher that we have custom content */
Winson Chung98ca0f72013-07-29 12:58:51 -0700568 protected boolean hasCustomContentToLeft() {
Adam Cohen9211d422014-10-07 18:14:53 -0700569 if (mLauncherCallbacks != null) {
570 return mLauncherCallbacks.hasCustomContentToLeft();
571 }
Winson Chung98ca0f72013-07-29 12:58:51 -0700572 return false;
573 }
574
Dave Hawkeya8881582013-09-17 15:55:33 -0600575 /**
Derek Prothrodadd9842014-01-17 13:43:50 -0500576 * To be overridden by subclasses to populate the custom content container and call
Dave Hawkeya8881582013-09-17 15:55:33 -0600577 * {@link #addToCustomContentPage}. This will only be invoked if
578 * {@link #hasCustomContentToLeft()} is {@code true}.
579 */
Derek Prothrodadd9842014-01-17 13:43:50 -0500580 protected void populateCustomContentContainer() {
Adam Cohen9211d422014-10-07 18:14:53 -0700581 if (mLauncherCallbacks != null) {
582 mLauncherCallbacks.populateCustomContentContainer();
583 }
Dave Hawkeya8881582013-09-17 15:55:33 -0600584 }
585
586 /**
Sunny Goyalfe770c92016-09-27 14:38:58 -0700587 * Invoked by subclasses to signal a change to the {@link #addToCustomContentPage} value to
Dave Hawkeya8881582013-09-17 15:55:33 -0600588 * ensure the custom content page is added or removed if necessary.
589 */
590 protected void invalidateHasCustomContentToLeft() {
Dave Hawkey3a733a72013-09-30 11:52:21 -0600591 if (mWorkspace == null || mWorkspace.getScreenOrder().isEmpty()) {
Dave Hawkeya8881582013-09-17 15:55:33 -0600592 // Not bound yet, wait for bindScreens to be called.
593 return;
594 }
595
596 if (!mWorkspace.hasCustomContent() && hasCustomContentToLeft()) {
597 // Create the custom content page and call the subclass to populate it.
Derek Prothrodadd9842014-01-17 13:43:50 -0500598 mWorkspace.createCustomContentContainer();
599 populateCustomContentContainer();
Dave Hawkeya8881582013-09-17 15:55:33 -0600600 } else if (mWorkspace.hasCustomContent() && !hasCustomContentToLeft()) {
601 mWorkspace.removeCustomContentPage();
602 }
603 }
604
Hyunyoung Song3f471442015-04-08 19:01:34 -0700605 public boolean isDraggingEnabled() {
Winson Chung36a62fe2012-05-06 18:04:42 -0700606 // We prevent dragging when we are loading the workspace as it is possible to pick up a view
607 // that is subsequently removed from the workspace in startBinding().
Sunny Goyal639e9062015-08-19 19:17:06 -0700608 return !isWorkspaceLoading();
Winson Chung36a62fe2012-05-06 18:04:42 -0700609 }
610
Adam Cohenc76e1dd2013-11-14 11:09:14 +0000611 public int getViewIdForItem(ItemInfo info) {
Sunny Goyale2fd14b2015-08-27 17:45:46 -0700612 // aapt-generated IDs have the high byte nonzero; clamp to the range under that.
613 // This cast is safe as long as the id < 0x00FFFFFF
614 // Since we jail all the dynamically generated views, there should be no clashes
615 // with any other views.
616 return (int) info.id;
Adam Cohenc76e1dd2013-11-14 11:09:14 +0000617 }
618
Tony Wickham010d2552017-01-20 08:15:28 -0800619 public PopupDataProvider getPopupDataProvider() {
620 return mPopupDataProvider;
621 }
622
Adam Cohenc76e1dd2013-11-14 11:09:14 +0000623 /**
Winson Chung557d6ed2011-07-08 15:34:52 -0700624 * Returns whether we should delay spring loaded mode -- for shortcuts and widgets that have
625 * a configuration step, this allows the proper animations to run after other transitions.
626 */
Sunny Goyal2100c782016-08-22 16:00:03 -0700627 private long completeAdd(
628 int requestCode, Intent intent, int appWidgetId, PendingRequestArgs info) {
629 long screenId = info.screenId;
630 if (info.container == LauncherSettings.Favorites.CONTAINER_DESKTOP) {
Adam Cohen83079e42014-09-19 17:43:08 -0700631 // When the screen id represents an actual screen (as opposed to a rank) we make sure
632 // that the drop page actually exists.
Sunny Goyal2100c782016-08-22 16:00:03 -0700633 screenId = ensurePendingDropLayoutExists(info.screenId);
Adam Cohen83079e42014-09-19 17:43:08 -0700634 }
Adam Cohendb364c32014-05-20 14:23:40 -0700635
Sunny Goyal2100c782016-08-22 16:00:03 -0700636 switch (requestCode) {
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800637 case REQUEST_CREATE_SHORTCUT:
Sunny Goyalfb5096d2016-09-08 14:32:06 -0700638 completeAddShortcut(intent, info.container, screenId, info.cellX, info.cellY, info);
Winson Chungb8472bb2011-08-05 13:49:21 -0700639 break;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800640 case REQUEST_CREATE_APPWIDGET:
Sunny Goyal2100c782016-08-22 16:00:03 -0700641 completeAddAppWidget(appWidgetId, info, null, null);
Winson Chungb8472bb2011-08-05 13:49:21 -0700642 break;
Sunny Goyalff572272014-07-23 13:58:07 -0700643 case REQUEST_RECONFIGURE_APPWIDGET:
Sunny Goyal2100c782016-08-22 16:00:03 -0700644 completeRestoreAppWidget(appWidgetId, LauncherAppWidgetInfo.RESTORE_COMPLETED);
Sunny Goyalff572272014-07-23 13:58:07 -0700645 break;
Sunny Goyald478c832016-04-01 12:04:16 -0700646 case REQUEST_BIND_PENDING_APPWIDGET: {
Sunny Goyal2100c782016-08-22 16:00:03 -0700647 int widgetId = appWidgetId;
648 LauncherAppWidgetInfo widgetInfo =
Sunny Goyald478c832016-04-01 12:04:16 -0700649 completeRestoreAppWidget(widgetId, LauncherAppWidgetInfo.FLAG_UI_NOT_READY);
Sunny Goyal2100c782016-08-22 16:00:03 -0700650 if (widgetInfo != null) {
Sunny Goyald478c832016-04-01 12:04:16 -0700651 // Since the view was just bound, also launch the configure activity if needed
652 LauncherAppWidgetProviderInfo provider = mAppWidgetManager
653 .getLauncherAppWidgetInfo(widgetId);
Sunny Goyal04a324a2017-01-20 21:08:59 -0800654 if (provider != null) {
655 new WidgetAddFlowHandler(provider)
656 .startConfigActivity(this, widgetInfo, REQUEST_RECONFIGURE_APPWIDGET);
Sunny Goyald478c832016-04-01 12:04:16 -0700657 }
658 }
659 break;
660 }
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800661 }
Sunny Goyal2100c782016-08-22 16:00:03 -0700662
Adam Cohendb364c32014-05-20 14:23:40 -0700663 return screenId;
Patrick Dubroy002cbf42011-03-03 16:36:21 -0800664 }
665
Adam Cohenc7cd2cb2014-11-17 17:45:34 -0800666 private void handleActivityResult(
Michael Jurka8b805b12012-04-18 14:23:14 -0700667 final int requestCode, final int resultCode, final Intent data) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700668 if (isWorkspaceLoading()) {
669 // process the result once the workspace has loaded.
670 mPendingActivityResult = new ActivityResultInfo(requestCode, resultCode, data);
671 return;
672 }
673 mPendingActivityResult = null;
674
Winson Chunge341d302013-08-16 14:31:00 -0700675 // Reset the startActivity waiting flag
Sunny Goyal2100c782016-08-22 16:00:03 -0700676 final PendingRequestArgs requestArgs = mPendingRequestArgs;
677 setWaitingForResult(null);
678 if (requestArgs == null) {
679 return;
680 }
681
682 final int pendingAddWidgetId = requestArgs.getWidgetId();
Winson Chunge341d302013-08-16 14:31:00 -0700683
Adam Cohenad4e15c2013-10-17 16:21:35 -0700684 Runnable exitSpringLoaded = new Runnable() {
685 @Override
686 public void run() {
687 exitSpringLoadedDragModeDelayed((resultCode != RESULT_CANCELED),
688 EXIT_SPRINGLOADED_MODE_SHORT_TIMEOUT, null);
689 }
690 };
691
Michael Jurka8b805b12012-04-18 14:23:14 -0700692 if (requestCode == REQUEST_BIND_APPWIDGET) {
Winsona1f79d32015-08-05 14:00:45 -0700693 // This is called only if the user did not previously have permissions to bind widgets
Adam Cohenad4e15c2013-10-17 16:21:35 -0700694 final int appWidgetId = data != null ?
Michael Jurka8b805b12012-04-18 14:23:14 -0700695 data.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1) : -1;
696 if (resultCode == RESULT_CANCELED) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700697 completeTwoStageWidgetDrop(RESULT_CANCELED, appWidgetId, requestArgs);
Adam Cohen689ff162014-05-08 17:27:56 -0700698 mWorkspace.removeExtraEmptyScreenDelayed(true, exitSpringLoaded,
Adam Cohenad4e15c2013-10-17 16:21:35 -0700699 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false);
Michael Jurka8b805b12012-04-18 14:23:14 -0700700 } else if (resultCode == RESULT_OK) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700701 addAppWidgetImpl(
702 appWidgetId, requestArgs, null,
Sunny Goyal04a324a2017-01-20 21:08:59 -0800703 requestArgs.getWidgetHandler(),
Sunny Goyal2100c782016-08-22 16:00:03 -0700704 ON_ACTIVITY_RESULT_ANIMATION_DELAY);
Michael Jurka8b805b12012-04-18 14:23:14 -0700705 }
706 return;
Michael Jurka336fd4f2013-09-12 00:05:02 +0200707 } else if (requestCode == REQUEST_PICK_WALLPAPER) {
708 if (resultCode == RESULT_OK && mWorkspace.isInOverviewMode()) {
Tony Wickhame3054412015-09-09 09:05:25 -0700709 // User could have free-scrolled between pages before picking a wallpaper; make sure
710 // we move to the closest one now.
711 mWorkspace.setCurrentPage(mWorkspace.getPageNearestToCenterOfScreen());
Winson Chungdc61c4d2015-04-20 18:26:57 -0700712 showWorkspace(false);
Michael Jurka336fd4f2013-09-12 00:05:02 +0200713 }
714 return;
Michael Jurka8b805b12012-04-18 14:23:14 -0700715 }
Michael Jurka336fd4f2013-09-12 00:05:02 +0200716
Adam Cohened66b2b2012-01-23 17:28:51 -0800717 boolean isWidgetDrop = (requestCode == REQUEST_PICK_APPWIDGET ||
Sunny Goyal5c97f512015-05-19 16:03:28 -0700718 requestCode == REQUEST_CREATE_APPWIDGET);
Romain Guyaad5ef42009-06-10 02:48:37 -0700719
Adam Cohened66b2b2012-01-23 17:28:51 -0800720 // We have special handling for widgets
721 if (isWidgetDrop) {
Adam Cohen4637b5a2013-11-04 18:21:24 -0800722 final int appWidgetId;
723 int widgetId = data != null ? data.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1)
724 : -1;
725 if (widgetId < 0) {
726 appWidgetId = pendingAddWidgetId;
727 } else {
728 appWidgetId = widgetId;
729 }
730
Adam Cohenad4e15c2013-10-17 16:21:35 -0700731 final int result;
Adam Cohenf0129b12013-11-04 17:57:36 -0800732 if (appWidgetId < 0 || resultCode == RESULT_CANCELED) {
Adam Cohendb364c32014-05-20 14:23:40 -0700733 Log.e(TAG, "Error: appWidgetId (EXTRA_APPWIDGET_ID) was not " +
734 "returned from the widget configuration activity.");
Adam Cohenad4e15c2013-10-17 16:21:35 -0700735 result = RESULT_CANCELED;
Sunny Goyal2100c782016-08-22 16:00:03 -0700736 completeTwoStageWidgetDrop(result, appWidgetId, requestArgs);
Adam Cohendb364c32014-05-20 14:23:40 -0700737 final Runnable onComplete = new Runnable() {
Adam Cohenad4e15c2013-10-17 16:21:35 -0700738 @Override
739 public void run() {
740 exitSpringLoadedDragModeDelayed(false, 0, null);
741 }
742 };
Adam Cohendb364c32014-05-20 14:23:40 -0700743
Sunny Goyal2100c782016-08-22 16:00:03 -0700744 mWorkspace.removeExtraEmptyScreenDelayed(true, onComplete,
745 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false);
746 } else {
747 if (requestArgs.container == LauncherSettings.Favorites.CONTAINER_DESKTOP) {
748 // When the screen id represents an actual screen (as opposed to a rank)
749 // we make sure that the drop page actually exists.
750 requestArgs.screenId =
751 ensurePendingDropLayoutExists(requestArgs.screenId);
Adam Cohendb364c32014-05-20 14:23:40 -0700752 }
Sunny Goyal2100c782016-08-22 16:00:03 -0700753 final CellLayout dropLayout =
754 mWorkspace.getScreenWithId(requestArgs.screenId);
755
756 dropLayout.setDropPending(true);
757 final Runnable onComplete = new Runnable() {
758 @Override
759 public void run() {
760 completeTwoStageWidgetDrop(resultCode, appWidgetId, requestArgs);
761 dropLayout.setDropPending(false);
762 }
763 };
764 mWorkspace.removeExtraEmptyScreenDelayed(true, onComplete,
765 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false);
Winson Chung5aaab772012-04-27 15:24:02 -0700766 }
Adam Cohened66b2b2012-01-23 17:28:51 -0800767 return;
768 }
769
Sunny Goyald478c832016-04-01 12:04:16 -0700770 if (requestCode == REQUEST_RECONFIGURE_APPWIDGET
771 || requestCode == REQUEST_BIND_PENDING_APPWIDGET) {
Sunny Goyalff572272014-07-23 13:58:07 -0700772 if (resultCode == RESULT_OK) {
773 // Update the widget view.
Sunny Goyal2100c782016-08-22 16:00:03 -0700774 completeAdd(requestCode, data, pendingAddWidgetId, requestArgs);
Sunny Goyalff572272014-07-23 13:58:07 -0700775 }
776 // Leave the widget in the pending state if the user canceled the configure.
777 return;
778 }
779
Sunny Goyalaad90582015-07-09 14:22:50 -0700780 if (requestCode == REQUEST_CREATE_SHORTCUT) {
781 // Handle custom shortcuts created using ACTION_CREATE_SHORTCUT.
Sunny Goyal2100c782016-08-22 16:00:03 -0700782 if (resultCode == RESULT_OK && requestArgs.container != ItemInfo.NO_ID) {
783 completeAdd(requestCode, data, -1, requestArgs);
784 mWorkspace.removeExtraEmptyScreenDelayed(true, exitSpringLoaded,
785 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false);
786
Sunny Goyalaad90582015-07-09 14:22:50 -0700787 } else if (resultCode == RESULT_CANCELED) {
Adam Cohendb364c32014-05-20 14:23:40 -0700788 mWorkspace.removeExtraEmptyScreenDelayed(true, exitSpringLoaded,
789 ON_ACTIVITY_RESULT_ANIMATION_DELAY, false);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800790 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800791 }
Adam Cohened66b2b2012-01-23 17:28:51 -0800792 mDragLayer.clearAnimatedView();
Adam Cohenc7cd2cb2014-11-17 17:45:34 -0800793 }
794
795 @Override
Sunny Goyaldec3a902017-01-25 18:23:36 -0800796 protected void onActivityResult(
Adam Cohenc7cd2cb2014-11-17 17:45:34 -0800797 final int requestCode, final int resultCode, final Intent data) {
798 handleActivityResult(requestCode, resultCode, data);
799 if (mLauncherCallbacks != null) {
800 mLauncherCallbacks.onActivityResult(requestCode, resultCode, data);
801 }
Adam Cohened66b2b2012-01-23 17:28:51 -0800802 }
803
Dave Hawkey3a43ed62015-06-26 10:27:47 -0600804 /** @Override for MNC */
Sunny Goyaldd2e6df2015-07-07 10:57:57 -0700805 public void onRequestPermissionsResult(int requestCode, String[] permissions,
Dave Hawkey3a43ed62015-06-26 10:27:47 -0600806 int[] grantResults) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700807 PendingRequestArgs pendingArgs = mPendingRequestArgs;
808 if (requestCode == REQUEST_PERMISSION_CALL_PHONE && pendingArgs != null
809 && pendingArgs.getRequestCode() == REQUEST_PERMISSION_CALL_PHONE) {
810 setWaitingForResult(null);
811
Sunny Goyal28c6b962015-10-12 11:42:05 -0700812 View v = null;
Sunny Goyal2100c782016-08-22 16:00:03 -0700813 CellLayout layout = getCellLayout(pendingArgs.container, pendingArgs.screenId);
Sunny Goyal28c6b962015-10-12 11:42:05 -0700814 if (layout != null) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700815 v = layout.getChildAt(pendingArgs.cellX, pendingArgs.cellY);
Sunny Goyal28c6b962015-10-12 11:42:05 -0700816 }
Sunny Goyal2100c782016-08-22 16:00:03 -0700817 Intent intent = pendingArgs.getPendingIntent();
818
Sunny Goyal28c6b962015-10-12 11:42:05 -0700819 if (grantResults.length > 0
820 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
Sunny Goyal85fc55a2016-05-31 10:44:03 -0700821 startActivitySafely(v, intent, null);
Sunny Goyal28c6b962015-10-12 11:42:05 -0700822 } else {
823 // TODO: Show a snack bar with link to settings
824 Toast.makeText(this, getString(R.string.msg_no_phone_permission,
Sunny Goyal112ce422016-08-22 16:45:29 -0700825 getString(R.string.derived_app_name)), Toast.LENGTH_SHORT).show();
Sunny Goyal28c6b962015-10-12 11:42:05 -0700826 }
827 }
Dave Hawkey3a43ed62015-06-26 10:27:47 -0600828 if (mLauncherCallbacks != null) {
829 mLauncherCallbacks.onRequestPermissionsResult(requestCode, permissions,
830 grantResults);
831 }
832 }
833
Adam Cohendb364c32014-05-20 14:23:40 -0700834 /**
835 * Check to see if a given screen id exists. If not, create it at the end, return the new id.
836 *
837 * @param screenId the screen id to check
838 * @return the new screen, or screenId if it exists
839 */
840 private long ensurePendingDropLayoutExists(long screenId) {
Sunny Goyal32554d12015-12-03 15:31:25 -0800841 CellLayout dropLayout = mWorkspace.getScreenWithId(screenId);
Adam Cohendb364c32014-05-20 14:23:40 -0700842 if (dropLayout == null) {
843 // it's possible that the add screen was removed because it was
844 // empty and a re-bind occurred
845 mWorkspace.addExtraEmptyScreen();
846 return mWorkspace.commitExtraEmptyScreen();
847 } else {
848 return screenId;
849 }
850 }
851
Sunny Goyal2100c782016-08-22 16:00:03 -0700852 @Thunk void completeTwoStageWidgetDrop(
853 final int resultCode, final int appWidgetId, final PendingRequestArgs requestArgs) {
854 CellLayout cellLayout = mWorkspace.getScreenWithId(requestArgs.screenId);
Adam Cohened66b2b2012-01-23 17:28:51 -0800855 Runnable onCompleteRunnable = null;
856 int animationType = 0;
857
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700858 AppWidgetHostView boundWidget = null;
Adam Cohened66b2b2012-01-23 17:28:51 -0800859 if (resultCode == RESULT_OK) {
860 animationType = Workspace.COMPLETE_TWO_STAGE_WIDGET_DROP_ANIMATION;
861 final AppWidgetHostView layout = mAppWidgetHost.createView(this, appWidgetId,
Sunny Goyal04a324a2017-01-20 21:08:59 -0800862 requestArgs.getWidgetHandler().getProviderInfo(this));
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700863 boundWidget = layout;
Adam Cohened66b2b2012-01-23 17:28:51 -0800864 onCompleteRunnable = new Runnable() {
865 @Override
866 public void run() {
Sunny Goyal2100c782016-08-22 16:00:03 -0700867 completeAddAppWidget(appWidgetId, requestArgs, layout, null);
Adam Cohenad4e15c2013-10-17 16:21:35 -0700868 exitSpringLoadedDragModeDelayed((resultCode != RESULT_CANCELED),
869 EXIT_SPRINGLOADED_MODE_SHORT_TIMEOUT, null);
Adam Cohened66b2b2012-01-23 17:28:51 -0800870 }
871 };
872 } else if (resultCode == RESULT_CANCELED) {
Adam Cohen4637b5a2013-11-04 18:21:24 -0800873 mAppWidgetHost.deleteAppWidgetId(appWidgetId);
Adam Cohened66b2b2012-01-23 17:28:51 -0800874 animationType = Workspace.CANCEL_TWO_STAGE_WIDGET_DROP_ANIMATION;
Adam Cohened66b2b2012-01-23 17:28:51 -0800875 }
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700876 if (mDragLayer.getAnimatedView() != null) {
Sunny Goyal2100c782016-08-22 16:00:03 -0700877 mWorkspace.animateWidgetDrop(requestArgs, cellLayout,
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700878 (DragView) mDragLayer.getAnimatedView(), onCompleteRunnable,
879 animationType, boundWidget, true);
Adam Cohenad4e15c2013-10-17 16:21:35 -0700880 } else if (onCompleteRunnable != null) {
Adam Cohen9d5b7d82012-05-09 18:00:44 -0700881 // The animated view may be null in the case of a rotation during widget configuration
882 onCompleteRunnable.run();
883 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800884 }
885
886 @Override
Michael Jurkacd496d72013-04-11 11:32:45 -0700887 protected void onStop() {
888 super.onStop();
889 FirstFrameAnimatorHelper.setIsVisible(false);
Adam Cohen9211d422014-10-07 18:14:53 -0700890
891 if (mLauncherCallbacks != null) {
892 mLauncherCallbacks.onStop();
893 }
Sunny Goyal5da78f42016-06-17 14:00:22 -0700894
Sunny Goyalf5e37442016-11-02 10:31:24 -0700895 if (Utilities.ATLEAST_NOUGAT_MR1) {
Sunny Goyal5da78f42016-06-17 14:00:22 -0700896 mAppWidgetHost.stopListening();
897 }
Tony Wickham010d2552017-01-20 08:15:28 -0800898
899 NotificationListener.removeNotificationsChangedListener();
Michael Jurkacd496d72013-04-11 11:32:45 -0700900 }
901
902 @Override
903 protected void onStart() {
904 super.onStart();
905 FirstFrameAnimatorHelper.setIsVisible(true);
Adam Cohen9211d422014-10-07 18:14:53 -0700906
907 if (mLauncherCallbacks != null) {
908 mLauncherCallbacks.onStart();
909 }
Sunny Goyal5da78f42016-06-17 14:00:22 -0700910
Sunny Goyalf5e37442016-11-02 10:31:24 -0700911 if (Utilities.ATLEAST_NOUGAT_MR1) {
Sunny Goyal5da78f42016-06-17 14:00:22 -0700912 mAppWidgetHost.startListening();
913 }
Tony Wickham010d2552017-01-20 08:15:28 -0800914
915 if (!isWorkspaceLoading()) {
916 NotificationListener.setNotificationsChangedListener(mPopupDataProvider);
917 }
Michael Jurkacd496d72013-04-11 11:32:45 -0700918 }
919
920 @Override
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800921 protected void onResume() {
Michael Jurka447bf842013-05-15 14:52:15 +0200922 long startTime = 0;
923 if (DEBUG_RESUME_TIME) {
924 startTime = System.currentTimeMillis();
Daniel Sandler924b9932013-06-12 00:38:25 -0400925 Log.v(TAG, "Launcher.onResume()");
Michael Jurka447bf842013-05-15 14:52:15 +0200926 }
Adam Cohen9211d422014-10-07 18:14:53 -0700927
928 if (mLauncherCallbacks != null) {
929 mLauncherCallbacks.preOnResume();
930 }
931
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800932 super.onResume();
Hyunyoung Songaa953652016-04-19 18:30:24 -0700933 getUserEventDispatcher().resetElapsedSessionMillis();
Winson Chungf0c6ae02012-03-21 16:10:31 -0700934
Winson Chung4a2afa32012-07-19 14:53:05 -0700935 // Restore the previous launcher state
Winson Chung75cc8252015-04-10 10:19:58 -0700936 if (mOnResumeState == State.WORKSPACE) {
Winson Chung4a2afa32012-07-19 14:53:05 -0700937 showWorkspace(false);
Winson Chungb745afb2015-03-02 11:51:23 -0800938 } else if (mOnResumeState == State.APPS) {
Winson Chung13eb5272015-05-11 16:30:13 -0700939 boolean launchedFromApp = (mWaitingForResume != null);
Winson Chung4ac30062015-05-08 17:34:17 -0700940 // Don't update the predicted apps if the user is returning to launcher in the apps
Winson Chung13eb5272015-05-11 16:30:13 -0700941 // view after launching an app, as they may be depending on the UI to be static to
942 // switch to another app, otherwise, if it was
Hyunyoung Songdd60ce42016-07-27 17:08:38 -0700943 showAppsView(false /* animated */, !launchedFromApp /* updatePredictedApps */,
Hyunyoung Songc2fe1142016-09-09 15:02:20 -0700944 mAppsView.shouldRestoreImeState() /* focusSearchBar */);
Winson Chungb745afb2015-03-02 11:51:23 -0800945 } else if (mOnResumeState == State.WIDGETS) {
946 showWidgetsView(false, false);
Winson Chung4a2afa32012-07-19 14:53:05 -0700947 }
948 mOnResumeState = State.NONE;
949
Joe Onorato34a0e1b2009-12-14 17:44:51 -0800950 mPaused = false;
Sunny Goyal2100c782016-08-22 16:00:03 -0700951 if (mOnResumeNeedsLoad) {
Anjali Koppalff7ceff2014-05-01 18:26:37 -0700952 setWorkspaceLoading(true);
Sunny Goyal93f878c2016-03-30 17:31:24 -0700953 mModel.startLoader(getCurrentWorkspaceScreen());
Joe Onoratoef2efcf2010-10-27 13:21:00 -0700954 mOnResumeNeedsLoad = false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800955 }
Michael Jurka1e2f4652013-07-08 18:03:46 -0700956 if (mBindOnResumeCallbacks.size() > 0) {
Michael Jurkac402cd92013-05-20 15:49:32 +0200957 // We might have postponed some bind calls until onResume (see waitUntilResume) --
958 // execute them here
959 long startTimeCallbacks = 0;
960 if (DEBUG_RESUME_TIME) {
961 startTimeCallbacks = System.currentTimeMillis();
962 }
963
Michael Jurka1e2f4652013-07-08 18:03:46 -0700964 for (int i = 0; i < mBindOnResumeCallbacks.size(); i++) {
965 mBindOnResumeCallbacks.get(i).run();
Michael Jurkac402cd92013-05-20 15:49:32 +0200966 }
Michael Jurka1e2f4652013-07-08 18:03:46 -0700967 mBindOnResumeCallbacks.clear();
Michael Jurkac402cd92013-05-20 15:49:32 +0200968 if (DEBUG_RESUME_TIME) {
969 Log.d(TAG, "Time spent processing callbacks in onResume: " +
970 (System.currentTimeMillis() - startTimeCallbacks));
971 }
Michael Jurka447bf842013-05-15 14:52:15 +0200972 }
Michael Jurka54554252013-08-01 12:52:23 +0200973 if (mOnResumeCallbacks.size() > 0) {
974 for (int i = 0; i < mOnResumeCallbacks.size(); i++) {
975 mOnResumeCallbacks.get(i).run();
976 }
977 mOnResumeCallbacks.clear();
978 }
Winson Chunge4e50662012-01-23 14:45:13 -0800979
980 // Reset the pressed state of icons that were locked in the press state while activities
981 // were launching
Michael Jurkaddd62e92011-02-16 17:49:14 -0800982 if (mWaitingForResume != null) {
Winson Chunge4e50662012-01-23 14:45:13 -0800983 // Resets the previous workspace icon press state
Michael Jurkaddd62e92011-02-16 17:49:14 -0800984 mWaitingForResume.setStayPressed(false);
985 }
Winson Chung82963d52013-10-09 11:20:57 -0700986
Adam Cohen06dff352012-06-01 17:17:08 -0700987 // It is possible that widgets can receive updates while launcher is not in the foreground.
988 // Consequently, the widgets will be inflated in the orientation of the foreground activity
989 // (framework issue). On resuming, we ensure that any widgets are inflated for the current
990 // orientation.
Sunny Goyal6bec75f2015-10-01 18:50:48 -0700991 if (!isWorkspaceLoading()) {
992 getWorkspace().reinflateWidgetsIfNecessary();
993 }
Adam Cohenf9426d52012-06-04 17:26:21 -0700994
Michael Jurka447bf842013-05-15 14:52:15 +0200995 if (DEBUG_RESUME_TIME) {
996 Log.d(TAG, "Time spent in onResume: " + (System.currentTimeMillis() - startTime));
997 }
Adam Cohen6fecd412013-10-02 17:41:50 -0700998
Adam Cohen4b66bf32015-09-18 12:15:19 -0700999 // We want to suppress callbacks about CustomContent being shown if we have just received
1000 // onNewIntent while the user was present within launcher. In that case, we post a call
1001 // to move the user to the main screen (which will occur after onResume). We don't want to
1002 // have onHide (from onPause), then onShow, then onHide again, which we get if we don't
1003 // suppress here.
1004 if (mWorkspace.getCustomContentCallbacks() != null
1005 && !mMoveToDefaultScreenFromNewIntent) {
Adam Cohen6fecd412013-10-02 17:41:50 -07001006 // If we are resuming and the custom content is the current page, we call onShow().
Adam Cohen4b66bf32015-09-18 12:15:19 -07001007 // It is also possible that onShow will instead be called slightly after first layout
Adam Cohen6fecd412013-10-02 17:41:50 -07001008 // if PagedView#setRestorePage was set to the custom content page in onCreate().
1009 if (mWorkspace.isOnOrMovingToCustomContent()) {
Selim Cinek3a8a8f72014-01-16 10:38:38 -08001010 mWorkspace.getCustomContentCallbacks().onShow(true);
Adam Cohen6fecd412013-10-02 17:41:50 -07001011 }
1012 }
Adam Cohen4b66bf32015-09-18 12:15:19 -07001013 mMoveToDefaultScreenFromNewIntent = false;
Winson Chungcd99cd32015-04-29 11:03:24 -07001014 updateInteraction(Workspace.State.NORMAL, mWorkspace.getState());
Adam Cohen53805212013-10-01 10:39:23 -07001015 mWorkspace.onResume();
Sunny Goyale755d462014-07-22 13:48:29 -07001016
Sunny Goyal756adbc2015-04-16 15:20:51 -07001017 if (!isWorkspaceLoading()) {
1018 // Process any items that were added while Launcher was away.
1019 InstallShortcutReceiver.disableAndFlushInstallQueue(this);
Sunny Goyal95f3d6b2016-08-10 16:09:29 -07001020
1021 // Refresh shortcuts if the permission changed.
1022 mModel.refreshShortcutsIfRequired();
Sunny Goyal756adbc2015-04-16 15:20:51 -07001023 }
Adam Cohen9211d422014-10-07 18:14:53 -07001024
Hyunyoung Songc001cf52016-07-21 17:32:43 -07001025 if (shouldShowDiscoveryBounce()) {
1026 mAllAppsController.showDiscoveryBounce();
1027 }
1028 mIsResumeFromActionScreenOff = false;
Adam Cohen9211d422014-10-07 18:14:53 -07001029 if (mLauncherCallbacks != null) {
1030 mLauncherCallbacks.onResume();
1031 }
Mario Bertschler0fc6f682017-02-17 12:16:13 -08001032
Adam Cohen06dff352012-06-01 17:17:08 -07001033 }
1034
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001035 @Override
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001036 protected void onPause() {
Winson Chung997a9232013-07-24 15:33:46 -07001037 // Ensure that items added to Launcher are queued until Launcher returns
1038 InstallShortcutReceiver.enableInstallQueue();
1039
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001040 super.onPause();
Joe Onoratoef2efcf2010-10-27 13:21:00 -07001041 mPaused = true;
Joe Onorato24b6fd82009-11-12 13:47:09 -08001042 mDragController.cancelDrag();
Winson Chunga2413752012-04-03 14:22:34 -07001043 mDragController.resetLastGestureUpTime();
Adam Cohen6fecd412013-10-02 17:41:50 -07001044
1045 // We call onHide() aggressively. The custom content callbacks should be able to
1046 // debounce excess onHide calls.
1047 if (mWorkspace.getCustomContentCallbacks() != null) {
1048 mWorkspace.getCustomContentCallbacks().onHide();
1049 }
Romain Guycbb89e42009-06-08 15:52:54 -07001050
Adam Cohen9211d422014-10-07 18:14:53 -07001051 if (mLauncherCallbacks != null) {
1052 mLauncherCallbacks.onPause();
Adam Cohenbffe7452013-07-22 18:21:45 -07001053 }
Adam Cohenbffe7452013-07-22 18:21:45 -07001054 }
1055
1056 public interface CustomContentCallbacks {
Selim Cinek3a8a8f72014-01-16 10:38:38 -08001057 // Custom content is completely shown. {@code fromResume} indicates whether this was caused
1058 // by a onResume or by scrolling otherwise.
1059 public void onShow(boolean fromResume);
Adam Cohenbffe7452013-07-22 18:21:45 -07001060
1061 // Custom content is completely hidden
1062 public void onHide();
Adam Cohenc36fa5c2013-08-29 11:54:42 -07001063
1064 // Custom content scroll progress changed. From 0 (not showing) to 1 (fully showing).
1065 public void onScrollProgressChanged(float progress);
Jan-Willem Maarse2ff91c42014-07-10 15:58:12 -07001066
1067 // Indicates whether the user is allowed to scroll away from the custom content.
1068 boolean isScrollingAllowed();
Adam Cohenbffe7452013-07-22 18:21:45 -07001069 }
1070
Adam Cohenc2d6e892014-10-16 09:49:24 -07001071 public interface LauncherOverlay {
1072
1073 /**
1074 * Touch interaction leading to overscroll has begun
1075 */
1076 public void onScrollInteractionBegin();
1077
1078 /**
1079 * Touch interaction related to overscroll has ended
1080 */
1081 public void onScrollInteractionEnd();
1082
1083 /**
1084 * Scroll progress, between 0 and 100, when the user scrolls beyond the leftmost
1085 * screen (or in the case of RTL, the rightmost screen).
1086 */
Sunny Goyalc86df472016-02-25 09:19:38 -08001087 public void onScrollChange(float progress, boolean rtl);
Adam Cohenc2d6e892014-10-16 09:49:24 -07001088
1089 /**
Sunny Goyal32554d12015-12-03 15:31:25 -08001090 * Called when the launcher is ready to use the overlay
1091 * @param callbacks A set of callbacks provided by Launcher in relation to the overlay
Adam Cohenc2d6e892014-10-16 09:49:24 -07001092 */
Sunny Goyal32554d12015-12-03 15:31:25 -08001093 public void setOverlayCallbacks(LauncherOverlayCallbacks callbacks);
Adam Cohenc2d6e892014-10-16 09:49:24 -07001094 }
1095
1096 public interface LauncherOverlayCallbacks {
Sunny Goyalc86df472016-02-25 09:19:38 -08001097 public void onScrollChanged(float progress);
Adam Cohenc2d6e892014-10-16 09:49:24 -07001098 }
1099
1100 class LauncherOverlayCallbacksImpl implements LauncherOverlayCallbacks {
1101
Sunny Goyalc86df472016-02-25 09:19:38 -08001102 public void onScrollChanged(float progress) {
1103 if (mWorkspace != null) {
1104 mWorkspace.onOverlayScrollChanged(progress);
1105 }
1106 }
Adam Cohenc2d6e892014-10-16 09:49:24 -07001107 }
1108
Jorim Jaggid017f882014-01-14 17:08:48 -08001109 protected boolean hasSettings() {
Adam Cohen9211d422014-10-07 18:14:53 -07001110 if (mLauncherCallbacks != null) {
1111 return mLauncherCallbacks.hasSettings();
Rahul Chaturvedi7fc77ca2015-05-19 18:02:16 -07001112 } else {
Sunny Goyal4179e9b2017-03-08 14:25:09 -08001113 // On O and above we there is always some setting present settings (add icon to
1114 // home screen or icon badging). On earlier APIs we will have the allow rotation
1115 // setting, on devices with a locked orientation,
1116 return Utilities.isAtLeastO() || !getResources().getBoolean(R.bool.allow_rotation);
Adam Cohen9211d422014-10-07 18:14:53 -07001117 }
Jorim Jaggid017f882014-01-14 17:08:48 -08001118 }
1119
Adam Cohen9211d422014-10-07 18:14:53 -07001120 public void addToCustomContentPage(View customContent,
Adam Cohen53805212013-10-01 10:39:23 -07001121 CustomContentCallbacks callbacks, String description) {
1122 mWorkspace.addToCustomContentPage(customContent, callbacks, description);
Adam Cohen66a01fd2013-06-11 12:48:00 -07001123 }
1124
Adam Cohenedb40762013-07-18 16:45:45 -07001125 // The custom content needs to offset its content to account for the QSB
1126 public int getTopOffsetForCustomContent() {
1127 return mWorkspace.getPaddingTop();
1128 }
1129
Jeffrey Sharkey99c87582009-03-24 17:59:43 -07001130 @Override
1131 public Object onRetainNonConfigurationInstance() {
Joe Onorato9c1289c2009-08-17 11:03:03 -04001132 // Flag the loader to stop early before switching
Adam Cohen1a85c582014-09-30 09:48:49 -07001133 if (mModel.isCurrentCallbacks(this)) {
1134 mModel.stopLoader();
1135 }
Hyunyoung Song3f471442015-04-08 19:01:34 -07001136 //TODO(hyunyoungs): stop the widgets loader when there is a rotation.
1137
Romain Guy13c2e7b2010-03-10 19:45:00 -08001138 return Boolean.TRUE;
Jeffrey Sharkey99c87582009-03-24 17:59:43 -07001139 }
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001140
Joe Onorato2d7e7d02010-01-29 15:57:19 -08001141 // We can't hide the IME if it was forced open. So don't bother
Joe Onorato2d7e7d02010-01-29 15:57:19 -08001142 @Override
1143 public void onWindowFocusChanged(boolean hasFocus) {
1144 super.onWindowFocusChanged(hasFocus);
Adam Cohened307df2013-10-02 09:37:31 -07001145 mHasFocus = hasFocus;
Adam Cohen9211d422014-10-07 18:14:53 -07001146
1147 if (mLauncherCallbacks != null) {
1148 mLauncherCallbacks.onWindowFocusChanged(hasFocus);
1149 }
Joe Onorato2d7e7d02010-01-29 15:57:19 -08001150 }
Joe Onorato2d7e7d02010-01-29 15:57:19 -08001151
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001152 private boolean acceptFilter() {
1153 final InputMethodManager inputManager = (InputMethodManager)
1154 getSystemService(Context.INPUT_METHOD_SERVICE);
1155 return !inputManager.isFullscreenMode();
1156 }
1157
1158 @Override
1159 public boolean onKeyDown(int keyCode, KeyEvent event) {
Winson Chung97d85d22011-04-13 11:27:36 -07001160 final int uniChar = event.getUnicodeChar();
1161 final boolean handled = super.onKeyDown(keyCode, event);
1162 final boolean isKeyNotWhitespace = uniChar > 0 && !Character.isWhitespace(uniChar);
1163 if (!handled && acceptFilter() && isKeyNotWhitespace) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001164 boolean gotKey = TextKeyListener.getInstance().onKeyDown(mWorkspace, mDefaultKeySsb,
1165 keyCode, event);
1166 if (gotKey && mDefaultKeySsb != null && mDefaultKeySsb.length() > 0) {
Karl Rosaen138a0412009-04-23 19:00:21 -07001167 // something usable has been typed - start a search
Romain Guycbb89e42009-06-08 15:52:54 -07001168 // the typed text will be retrieved and cleared by
Karl Rosaen138a0412009-04-23 19:00:21 -07001169 // showSearchDialog()
1170 // If there are multiple keystrokes before the search dialog takes focus,
1171 // onSearchRequested() will be called for every keystroke,
1172 // but it is idempotent, so it's fine.
1173 return onSearchRequested();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001174 }
1175 }
1176
Joe Onorato8a9625e2010-01-28 15:55:35 -08001177 // Eat the long press event so the keyboard doesn't come up.
1178 if (keyCode == KeyEvent.KEYCODE_MENU && event.isLongPress()) {
1179 return true;
1180 }
1181
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001182 return handled;
1183 }
1184
Winson46163472015-09-22 17:31:56 -07001185 @Override
1186 public boolean onKeyUp(int keyCode, KeyEvent event) {
1187 if (keyCode == KeyEvent.KEYCODE_MENU) {
1188 // Ignore the menu key if we are currently dragging or are on the custom content screen
1189 if (!isOnCustomContent() && !mDragController.isDragging()) {
Sunny Goyal740ac7f2016-09-28 16:47:32 -07001190 // Close any open floating view
1191 AbstractFloatingView.closeAllOpenViews(this);
Tony Wickham49c8d292016-07-01 11:44:34 -07001192
Winson46163472015-09-22 17:31:56 -07001193 // Stop resizing any widgets
1194 mWorkspace.exitWidgetResizeMode();
1195
1196 // Show the overview mode if we are on the workspace
1197 if (mState == State.WORKSPACE && !mWorkspace.isInOverviewMode() &&
1198 !mWorkspace.isSwitchingState()) {
1199 mOverviewPanel.requestFocus();
Winsone9f27272015-10-13 10:47:51 -07001200 showOverviewMode(true, true /* requestButtonFocus */);
Winson46163472015-09-22 17:31:56 -07001201 }
1202 }
1203 return true;
1204 }
1205 return super.onKeyUp(keyCode, event);
1206 }
1207
Karl Rosaen138a0412009-04-23 19:00:21 -07001208 private String getTypedText() {
1209 return mDefaultKeySsb.toString();
1210 }
1211
Sunny Goyal6f28e712016-09-13 14:19:29 -07001212 @Override
1213 public void clearTypedText() {
Karl Rosaen138a0412009-04-23 19:00:21 -07001214 mDefaultKeySsb.clear();
1215 mDefaultKeySsb.clearSpans();
1216 Selection.setSelection(mDefaultKeySsb, 0);
1217 }
1218
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001219 /**
1220 * Restores the previous state, if it exists.
1221 *
1222 * @param savedState The previous state.
1223 */
1224 private void restoreState(Bundle savedState) {
1225 if (savedState == null) {
1226 return;
1227 }
1228
Sunny Goyalfe770c92016-09-27 14:38:58 -07001229 int stateOrdinal = savedState.getInt(RUNTIME_STATE, State.WORKSPACE.ordinal());
1230 State[] stateValues = State.values();
1231 State state = (stateOrdinal >= 0 && stateOrdinal < stateValues.length)
1232 ? stateValues[stateOrdinal] : State.WORKSPACE;
Winson Chungb745afb2015-03-02 11:51:23 -08001233 if (state == State.APPS || state == State.WIDGETS) {
1234 mOnResumeState = state;
Joe Onorato3a8820b2009-11-10 15:06:42 -08001235 }
1236
Sunny Goyal2100c782016-08-22 16:00:03 -07001237 PendingRequestArgs requestArgs = savedState.getParcelable(RUNTIME_STATE_PENDING_REQUEST_ARGS);
1238 if (requestArgs != null) {
1239 setWaitingForResult(requestArgs);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001240 }
Sunny Goyal2100c782016-08-22 16:00:03 -07001241
1242 mPendingActivityResult = savedState.getParcelable(RUNTIME_STATE_PENDING_ACTIVITY_RESULT);
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 */
1248 private void setupViews() {
Winson Chung4c98d922011-05-31 16:50:48 -07001249 mDragLayer = (DragLayer) findViewById(R.id.drag_layer);
Sunny Goyal3333b0c2016-05-09 20:43:21 -07001250 mFocusHandler = mDragLayer.getFocusIndicatorHelper();
Winson Chung4c98d922011-05-31 16:50:48 -07001251 mWorkspace = (Workspace) mDragLayer.findViewById(R.id.workspace);
Sunny Goyal6178f132016-07-11 17:30:03 -07001252 mQsbContainer = mDragLayer.findViewById(mDeviceProfile.isVerticalBarLayout()
1253 ? R.id.workspace_blocked_row : R.id.qsb_container);
Sunny Goyald0a6ae72016-06-16 12:29:03 -07001254 mWorkspace.initParentViews(mDragLayer);
Craig Mautner360310b2012-10-26 15:13:08 -07001255
Sunny Goyal784f9c32016-03-23 16:56:54 -07001256 mLauncherView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
1257 | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
1258 | View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001259
Winson Chung4c98d922011-05-31 16:50:48 -07001260 // Setup the drag layer
Hyunyoung Song645764e2016-06-06 14:19:02 -07001261 mDragLayer.setup(this, mDragController, mAllAppsController);
Winson Chung4c98d922011-05-31 16:50:48 -07001262
Winson Chung3d503fb2011-07-13 17:25:49 -07001263 // Setup the hotseat
1264 mHotseat = (Hotseat) findViewById(R.id.hotseat);
1265 if (mHotseat != null) {
Winson Chung11a1a532013-09-13 11:14:45 -07001266 mHotseat.setOnLongClickListener(this);
Winson Chung3d503fb2011-07-13 17:25:49 -07001267 }
1268
Winsone9f27272015-10-13 10:47:51 -07001269 // Setup the overview panel
1270 setupOverviewPanel();
Adam Cohenf358a4b2013-07-23 16:47:31 -07001271
Winson Chung4c98d922011-05-31 16:50:48 -07001272 // Setup the workspace
1273 mWorkspace.setHapticFeedbackEnabled(false);
1274 mWorkspace.setOnLongClickListener(this);
Hyunyoung Song645764e2016-06-06 14:19:02 -07001275 mWorkspace.setup(mDragController);
Winsonc7d2e832016-07-28 12:24:55 -07001276 // Until the workspace is bound, ensure that we keep the wallpaper offset locked to the
1277 // default state, otherwise we will update to the wrong offsets in RTL
1278 mWorkspace.lockWallpaperToDefaultPage();
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07001279 mWorkspace.bindAndInitFirstWorkspaceScreen(null /* recycled qsb */);
Hyunyoung Song645764e2016-06-06 14:19:02 -07001280 mDragController.addDragListener(mWorkspace);
Winson Chung4c98d922011-05-31 16:50:48 -07001281
Tony Wickham34d2c912015-09-11 09:27:58 -07001282 // Get the search/delete/uninstall bar
Sunny Goyal47328fd2016-05-25 18:56:41 -07001283 mDropTargetBar = (DropTargetBar) mDragLayer.findViewById(R.id.drop_target_bar);
Patrick Dubroy3ec8bdd2010-08-06 16:01:33 -07001284
Winson Chungef7f8742015-06-04 17:18:17 -07001285 // Setup Apps and Widgets
Winson Chung5f4e0fd2015-05-22 11:12:27 -07001286 mAppsView = (AllAppsContainerView) findViewById(R.id.apps_view);
Hyunyoung Song3f471442015-04-08 19:01:34 -07001287 mWidgetsView = (WidgetsContainerView) findViewById(R.id.widgets_view);
Craig Mautner360310b2012-10-26 15:13:08 -07001288
Winson Chung3d503fb2011-07-13 17:25:49 -07001289 // Setup the drag controller (drop targets have to be added in reverse order in priority)
Hyunyoung Song645764e2016-06-06 14:19:02 -07001290 mDragController.setMoveTarget(mWorkspace);
1291 mDragController.addDropTarget(mWorkspace);
Sunny Goyal47328fd2016-05-25 18:56:41 -07001292 mDropTargetBar.setup(mDragController);
Daniel Sandler924b9932013-06-12 00:38:25 -04001293
Peter Schiller310a9882016-06-30 13:52:36 -07001294 if (FeatureFlags.LAUNCHER3_ALL_APPS_PULL_UP) {
1295 mAllAppsController.setupViews(mAppsView, mHotseat, mWorkspace);
1296 }
Hyunyoung Songa0c56472016-06-20 13:54:42 -07001297
Sunny Goyal322d5562015-06-25 19:35:49 -07001298 if (TestingUtils.MEMORY_DUMP_ENABLED) {
1299 TestingUtils.addWeightWatcher(this);
Daniel Sandler924b9932013-06-12 00:38:25 -04001300 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001301 }
1302
Winsone9f27272015-10-13 10:47:51 -07001303 private void setupOverviewPanel() {
1304 mOverviewPanel = (ViewGroup) findViewById(R.id.overview_panel);
1305
Winsone9f27272015-10-13 10:47:51 -07001306 // Bind wallpaper button actions
1307 View wallpaperButton = findViewById(R.id.wallpaper_button);
Sunny Goyal6c46a6d2016-11-23 02:24:32 +05301308 new OverviewButtonClickListener(ControlType.WALLPAPER_BUTTON) {
Winsone9f27272015-10-13 10:47:51 -07001309 @Override
Jon Mirandaf3e35d92016-10-05 14:08:11 -07001310 public void handleViewClick(View view) {
1311 onClickWallpaperPicker(view);
Winsone9f27272015-10-13 10:47:51 -07001312 }
Jon Mirandaf3e35d92016-10-05 14:08:11 -07001313 }.attachTo(wallpaperButton);
Winsone9f27272015-10-13 10:47:51 -07001314 wallpaperButton.setOnTouchListener(getHapticFeedbackTouchListener());
1315
1316 // Bind widget button actions
1317 mWidgetsButton = findViewById(R.id.widget_button);
Sunny Goyal6c46a6d2016-11-23 02:24:32 +05301318 new OverviewButtonClickListener(ControlType.WIDGETS_BUTTON) {
Winsone9f27272015-10-13 10:47:51 -07001319 @Override
Jon Mirandaf3e35d92016-10-05 14:08:11 -07001320 public void handleViewClick(View view) {
1321 onClickAddWidgetButton(view);
Winsone9f27272015-10-13 10:47:51 -07001322 }
Jon Mirandaf3e35d92016-10-05 14:08:11 -07001323 }.attachTo(mWidgetsButton);
Winsone9f27272015-10-13 10:47:51 -07001324 mWidgetsButton.setOnTouchListener(getHapticFeedbackTouchListener());
1325
1326 // Bind settings actions
1327 View settingsButton = findViewById(R.id.settings_button);
1328 boolean hasSettings = hasSettings();
1329 if (hasSettings) {
Sunny Goyal6c46a6d2016-11-23 02:24:32 +05301330 new OverviewButtonClickListener(ControlType.SETTINGS_BUTTON) {
Winsone9f27272015-10-13 10:47:51 -07001331 @Override
Jon Mirandaf3e35d92016-10-05 14:08:11 -07001332 public void handleViewClick(View view) {
1333 onClickSettingsButton(view);
Winsone9f27272015-10-13 10:47:51 -07001334 }
Jon Mirandaf3e35d92016-10-05 14:08:11 -07001335 }.attachTo(settingsButton);
Winsone9f27272015-10-13 10:47:51 -07001336 settingsButton.setOnTouchListener(getHapticFeedbackTouchListener());
1337 } else {
1338 settingsButton.setVisibility(View.GONE);
1339 }
1340
1341 mOverviewPanel.setAlpha(0f);
1342 }
1343
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001344 /**
Anjali Koppal5ad44842014-03-10 20:34:39 -07001345 * Sets the all apps button. This method is called from {@link Hotseat}.
Sunny Goyalbb011da2016-06-15 15:42:29 -07001346 * TODO: Get rid of this.
Anjali Koppal5ad44842014-03-10 20:34:39 -07001347 */
1348 public void setAllAppsButton(View allAppsButton) {
1349 mAllAppsButton = allAppsButton;
1350 }
1351
Sunny Goyalbb011da2016-06-15 15:42:29 -07001352 public View getStartViewForAllAppsRevealAnimation() {
Sunny Goyal2e084092016-06-22 14:37:34 -07001353 return FeatureFlags.NO_ALL_APPS_ICON ? mWorkspace.getPageIndicator() : mAllAppsButton;
Anjali Koppal5ad44842014-03-10 20:34:39 -07001354 }
1355
Hyunyoung Song98ff38a2015-07-10 17:50:13 -07001356 public View getWidgetsButton() {
1357 return mWidgetsButton;
1358 }
1359
Anjali Koppal5ad44842014-03-10 20:34:39 -07001360 /**
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001361 * Creates a view representing a shortcut.
1362 *
1363 * @param info The data structure describing the shortcut.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001364 */
Joe Onorato0589f0f2010-02-08 13:44:00 -08001365 View createShortcut(ShortcutInfo info) {
Sunny Goyaldfaccf62015-05-11 16:30:44 -07001366 return createShortcut((ViewGroup) mWorkspace.getChildAt(mWorkspace.getCurrentPage()), info);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001367 }
1368
1369 /**
1370 * Creates a view representing a shortcut inflated from the specified resource.
1371 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001372 * @param parent The group the shortcut belongs to.
1373 * @param info The data structure describing the shortcut.
1374 *
1375 * @return A View inflated from layoutResId.
1376 */
Sunny Goyaldfaccf62015-05-11 16:30:44 -07001377 public View createShortcut(ViewGroup parent, ShortcutInfo info) {
Sunny Goyal9b29ca52017-02-17 10:39:44 -08001378 BubbleTextView favorite = (BubbleTextView) LayoutInflater.from(parent.getContext())
1379 .inflate(R.layout.app_icon, parent, false);
Sunny Goyal1cd01b02016-11-09 10:43:58 -08001380 favorite.applyFromShortcutInfo(info);
Sunny Goyaldfaccf62015-05-11 16:30:44 -07001381 favorite.setCompoundDrawablePadding(mDeviceProfile.iconDrawablePaddingPx);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001382 favorite.setOnClickListener(this);
Sunny Goyaldcbcc862014-08-12 15:58:36 -07001383 favorite.setOnFocusChangeListener(mFocusHandler);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001384 return favorite;
1385 }
1386
1387 /**
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001388 * Add a shortcut to the workspace.
1389 *
1390 * @param data The intent describing the shortcut.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001391 */
Adam Cohendcd297f2013-06-18 13:13:40 -07001392 private void completeAddShortcut(Intent data, long container, long screenId, int cellX,
Sunny Goyalfb5096d2016-09-08 14:32:06 -07001393 int cellY, PendingRequestArgs args) {
Winson Chung3d503fb2011-07-13 17:25:49 -07001394 int[] cellXY = mTmpAddItemCellCoordinates;
Adam Cohendcd297f2013-06-18 13:13:40 -07001395 CellLayout layout = getCellLayout(container, screenId);
Romain Guycbb89e42009-06-08 15:52:54 -07001396
Sunny Goyal782f0c92017-01-19 10:27:54 -08001397 if (args.getRequestCode() != REQUEST_CREATE_SHORTCUT ||
Sunny Goyalfb5096d2016-09-08 14:32:06 -07001398 args.getPendingIntent().getComponent() == null) {
1399 return;
1400 }
Adam Cohen558baaf2011-08-15 15:22:57 -07001401
Sunny Goyal782f0c92017-01-19 10:27:54 -08001402 ShortcutInfo info = null;
1403 if (Utilities.isAtLeastO()) {
Sunny Goyaldec3a902017-01-25 18:23:36 -08001404 info = LauncherAppsCompat.createShortcutInfoFromPinItemRequest(
Sunny Goyal8a39b422017-03-30 15:30:47 -07001405 this, PinItemRequestCompat.getPinItemRequest(data), 0);
Sunny Goyal782f0c92017-01-19 10:27:54 -08001406 }
1407
1408 if (info == null) {
Sunny Goyalb57645f2017-03-20 13:57:28 -07001409 // Legacy shortcuts are only supported for primary profile.
1410 info = Process.myUserHandle().equals(args.user)
1411 ? InstallShortcutReceiver.fromShortcutIntent(this, data) : null;
Sunny Goyal782f0c92017-01-19 10:27:54 -08001412
Sunny Goyalb57645f2017-03-20 13:57:28 -07001413 if (info == null) {
1414 Log.e(TAG, "Unable to parse a valid custom shortcut result");
1415 return;
1416 } else if (!new PackageManagerHelper(this).hasPermissionForActivity(
Sunny Goyal342e4662017-02-02 15:21:08 -08001417 info.intent, args.getPendingIntent().getComponent().getPackageName())) {
Sunny Goyal782f0c92017-01-19 10:27:54 -08001418 // The app is trying to add a shortcut without sufficient permissions
1419 Log.e(TAG, "Ignoring malicious intent " + info.intent.toUri(0));
1420 return;
1421 }
1422 }
1423
1424 final View view = createShortcut(info);
Sunny Goyal5c97f512015-05-19 16:03:28 -07001425 boolean foundCellSpan = false;
Adam Cohenfbba09b2011-07-18 21:43:05 -07001426 // First we check if we already know the exact location where we want to add this item.
1427 if (cellX >= 0 && cellY >= 0) {
1428 cellXY[0] = cellX;
1429 cellXY[1] = cellY;
1430 foundCellSpan = true;
Adam Cohen558baaf2011-08-15 15:22:57 -07001431
1432 // If appropriate, either create a folder or add to an existing folder
Adam Cohen482ed822012-03-02 14:15:13 -08001433 if (mWorkspace.createUserFolderIfNecessary(view, container, layout, cellXY, 0,
Adam Cohen558baaf2011-08-15 15:22:57 -07001434 true, null,null)) {
1435 return;
1436 }
1437 DragObject dragObject = new DragObject();
1438 dragObject.dragInfo = info;
Adam Cohen482ed822012-03-02 14:15:13 -08001439 if (mWorkspace.addToExistingFolderIfNecessary(view, layout, cellXY, 0, dragObject,
1440 true)) {
Adam Cohen558baaf2011-08-15 15:22:57 -07001441 return;
1442 }
Michael Jurkad3ef3062010-11-23 16:23:58 -08001443 } else {
Adam Cohenfbba09b2011-07-18 21:43:05 -07001444 foundCellSpan = layout.findCellForSpan(cellXY, 1, 1);
Michael Jurkad3ef3062010-11-23 16:23:58 -08001445 }
1446
1447 if (!foundCellSpan) {
Jon Miranda9485e5f2016-10-18 11:47:42 -07001448 mWorkspace.onNoCellFound(layout);
Michael Jurka0280c3b2010-09-17 15:00:07 -07001449 return;
1450 }
1451
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001452 getModelWriter().addItemToDatabase(info, container, screenId, cellXY[0], cellXY[1]);
Sunny Goyald5462aa2016-11-22 16:52:39 +05301453 mWorkspace.addInScreen(view, info);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001454 }
1455
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001456 /**
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001457 * Add a widget to the workspace.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001458 *
Romain Guy5bbc91b2010-08-18 11:38:46 -07001459 * @param appWidgetId The app widget id
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001460 */
Sunny Goyal2100c782016-08-22 16:00:03 -07001461 @Thunk void completeAddAppWidget(int appWidgetId, ItemInfo itemInfo,
Adam Cohen59400422014-03-05 18:07:04 -08001462 AppWidgetHostView hostView, LauncherAppWidgetProviderInfo appWidgetInfo) {
1463
Adam Cohened66b2b2012-01-23 17:28:51 -08001464 if (appWidgetInfo == null) {
Sunny Goyal2e1efb42016-03-03 16:58:55 -08001465 appWidgetInfo = mAppWidgetManager.getLauncherAppWidgetInfo(appWidgetId);
Adam Cohened66b2b2012-01-23 17:28:51 -08001466 }
Romain Guycbb89e42009-06-08 15:52:54 -07001467
Adam Cohen59400422014-03-05 18:07:04 -08001468 if (appWidgetInfo.isCustomWidget) {
1469 appWidgetId = LauncherAppWidgetInfo.CUSTOM_WIDGET_ID;
Michael Jurkaa63c4522010-08-19 13:52:27 -07001470 }
1471
Adam Cohen59400422014-03-05 18:07:04 -08001472 LauncherAppWidgetInfo launcherInfo;
1473 launcherInfo = new LauncherAppWidgetInfo(appWidgetId, appWidgetInfo.provider);
Sunny Goyal2100c782016-08-22 16:00:03 -07001474 launcherInfo.spanX = itemInfo.spanX;
1475 launcherInfo.spanY = itemInfo.spanY;
1476 launcherInfo.minSpanX = itemInfo.minSpanX;
1477 launcherInfo.minSpanY = itemInfo.minSpanY;
Sunny Goyala52ecb02016-12-16 15:04:51 -08001478 launcherInfo.user = appWidgetInfo.getUser();
Romain Guycbb89e42009-06-08 15:52:54 -07001479
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001480 getModelWriter().addItemToDatabase(launcherInfo,
Sunny Goyal2100c782016-08-22 16:00:03 -07001481 itemInfo.container, itemInfo.screenId, itemInfo.cellX, itemInfo.cellY);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001482
Sunny Goyal2100c782016-08-22 16:00:03 -07001483 if (hostView == null) {
1484 // Perform actual inflation because we're live
1485 hostView = mAppWidgetHost.createView(this, appWidgetId, appWidgetInfo);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001486 }
Sunny Goyal2100c782016-08-22 16:00:03 -07001487 hostView.setVisibility(View.VISIBLE);
Sunny Goyald5462aa2016-11-22 16:52:39 +05301488 prepareAppWidget(hostView, launcherInfo);
1489 mWorkspace.addInScreen(hostView, launcherInfo);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001490 }
Romain Guycbb89e42009-06-08 15:52:54 -07001491
Sunny Goyald5462aa2016-11-22 16:52:39 +05301492 private void prepareAppWidget(AppWidgetHostView hostView, LauncherAppWidgetInfo item) {
Sunny Goyal87af0fd2016-05-16 14:56:02 -07001493 hostView.setTag(item);
1494 item.onBindAppWidget(this, hostView);
Sunny Goyal87af0fd2016-05-16 14:56:02 -07001495 hostView.setFocusable(true);
1496 hostView.setOnFocusChangeListener(mFocusHandler);
Sunny Goyal25c2e3e2015-10-28 23:28:21 -07001497 }
1498
Adam Cohended9f8d2010-11-03 13:25:16 -07001499 private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
1500 @Override
1501 public void onReceive(Context context, Intent intent) {
1502 final String action = intent.getAction();
1503 if (Intent.ACTION_SCREEN_OFF.equals(action)) {
Sunny Goyal6ad72f02016-09-23 11:01:10 -07001504 mDragLayer.clearResizeFrame();
Winson Chung337cd9d2011-03-30 10:39:30 -07001505
Winson Chungc100e8e2011-08-09 16:02:43 -07001506 // Reset AllApps to its initial state only if we are not in the middle of
Winson Chungb8472bb2011-08-05 13:49:21 -07001507 // processing a multi-step drop
Sunny Goyal2100c782016-08-22 16:00:03 -07001508 if (mAppsView != null && mWidgetsView != null && mPendingRequestArgs == null) {
Winson5c6bdbb2015-09-03 11:36:19 -07001509 if (!showWorkspace(false)) {
1510 // If we are already on the workspace, then manually reset all apps
1511 mAppsView.reset();
1512 }
Winson Chung785d2eb2011-04-14 16:08:02 -07001513 }
Hyunyoung Songc001cf52016-07-21 17:32:43 -07001514 mIsResumeFromActionScreenOff = true;
Adam Cohended9f8d2010-11-03 13:25:16 -07001515 }
1516 }
1517 };
1518
Tony Wickham010d2552017-01-20 08:15:28 -08001519 public void updateIconBadges(final Set<PackageUserKey> updatedBadges) {
1520 Runnable r = new Runnable() {
1521 @Override
1522 public void run() {
1523 mWorkspace.updateIconBadges(updatedBadges);
1524 mAppsView.updateIconBadges(updatedBadges);
Tony Wickham2fe09f22017-04-25 12:46:04 -07001525
1526 PopupContainerWithArrow popup = PopupContainerWithArrow.getOpen(Launcher.this);
1527 if (popup != null) {
1528 popup.updateNotificationHeader(updatedBadges);
1529 }
Tony Wickham010d2552017-01-20 08:15:28 -08001530 }
1531 };
1532 if (!waitUntilResume(r)) {
1533 r.run();
1534 }
1535 }
1536
Adam Cohended9f8d2010-11-03 13:25:16 -07001537 @Override
1538 public void onAttachedToWindow() {
1539 super.onAttachedToWindow();
1540
1541 // Listen for broadcasts related to user-presence
1542 final IntentFilter filter = new IntentFilter();
1543 filter.addAction(Intent.ACTION_SCREEN_OFF);
Adam Cohended9f8d2010-11-03 13:25:16 -07001544 registerReceiver(mReceiver, filter);
Michael Jurkaf1ad6082013-03-13 12:55:46 +01001545 FirstFrameAnimatorHelper.initializeDrawListener(getWindow().getDecorView());
Adam Cohend113e0c2010-11-11 10:48:05 -08001546 mAttached = true;
Sunny Goyalc86df472016-02-25 09:19:38 -08001547
1548 if (mLauncherCallbacks != null) {
1549 mLauncherCallbacks.onAttachedToWindow();
1550 }
Adam Cohended9f8d2010-11-03 13:25:16 -07001551 }
1552
1553 @Override
1554 public void onDetachedFromWindow() {
1555 super.onDetachedFromWindow();
Adam Cohend113e0c2010-11-11 10:48:05 -08001556 if (mAttached) {
1557 unregisterReceiver(mReceiver);
1558 mAttached = false;
1559 }
Sunny Goyalc86df472016-02-25 09:19:38 -08001560
1561 if (mLauncherCallbacks != null) {
1562 mLauncherCallbacks.onDetachedFromWindow();
1563 }
Adam Cohended9f8d2010-11-03 13:25:16 -07001564 }
1565
1566 public void onWindowVisibilityChanged(int visibility) {
Michael Jurka2a4b1a82011-12-07 14:00:02 -08001567 // The following code used to be in onResume, but it turns out onResume is called when
1568 // you're in All Apps and click home to go to the workspace. onWindowVisibilityChanged
1569 // is a more appropriate event to handle
Sunny Goyal1acc56a2016-09-25 21:23:25 -07001570 if (visibility == View.VISIBLE) {
Michael Jurka2a4b1a82011-12-07 14:00:02 -08001571 if (!mWorkspaceLoading) {
1572 final ViewTreeObserver observer = mWorkspace.getViewTreeObserver();
Michael Jurka2a4b1a82011-12-07 14:00:02 -08001573 // We want to let Launcher draw itself at least once before we force it to build
1574 // layers on all the workspace pages, so that transitioning to Launcher from other
Michael Jurkaf1ad6082013-03-13 12:55:46 +01001575 // apps is nice and speedy.
1576 observer.addOnDrawListener(new ViewTreeObserver.OnDrawListener() {
Michael Jurkadf96add2013-04-03 16:25:02 -07001577 private boolean mStarted = false;
Michael Jurkaf1ad6082013-03-13 12:55:46 +01001578 public void onDraw() {
Michael Jurkadf96add2013-04-03 16:25:02 -07001579 if (mStarted) return;
1580 mStarted = true;
Michael Jurka6ee21d22012-02-21 18:20:27 -08001581 // We delay the layer building a bit in order to give
1582 // other message processing a time to run. In particular
1583 // this avoids a delay in hiding the IME if it was
1584 // currently shown, because doing that may involve
1585 // some communication back with the app.
Winson Chungaeae56b2012-02-24 15:47:27 -08001586 mWorkspace.postDelayed(mBuildLayersRunnable, 500);
Michael Jurkadf96add2013-04-03 16:25:02 -07001587 final ViewTreeObserver.OnDrawListener listener = this;
1588 mWorkspace.post(new Runnable() {
Tony Wickhama0628cc2015-10-14 15:23:04 -07001589 public void run() {
1590 if (mWorkspace != null &&
1591 mWorkspace.getViewTreeObserver() != null) {
1592 mWorkspace.getViewTreeObserver().
1593 removeOnDrawListener(listener);
Michael Jurkadf96add2013-04-03 16:25:02 -07001594 }
Tony Wickhama0628cc2015-10-14 15:23:04 -07001595 }
1596 });
Michael Jurkaf1ad6082013-03-13 12:55:46 +01001597 return;
Michael Jurka2a4b1a82011-12-07 14:00:02 -08001598 }
1599 });
1600 }
1601 clearTypedText();
1602 }
Adam Cohended9f8d2010-11-03 13:25:16 -07001603 }
1604
Winson Chunga6945242014-01-08 14:04:34 -08001605 public DragLayer getDragLayer() {
1606 return mDragLayer;
1607 }
1608
Winson Chung5f4e0fd2015-05-22 11:12:27 -07001609 public AllAppsContainerView getAppsView() {
Winson Chungb745afb2015-03-02 11:51:23 -08001610 return mAppsView;
1611 }
1612
Hyunyoung Song3f471442015-04-08 19:01:34 -07001613 public WidgetsContainerView getWidgetsView() {
1614 return mWidgetsView;
Winson Chungb745afb2015-03-02 11:51:23 -08001615 }
1616
Winson Chunga6945242014-01-08 14:04:34 -08001617 public Workspace getWorkspace() {
1618 return mWorkspace;
1619 }
1620
Sunny Goyal6178f132016-07-11 17:30:03 -07001621 public View getQsbContainer() {
1622 return mQsbContainer;
1623 }
1624
Winson Chunga6945242014-01-08 14:04:34 -08001625 public Hotseat getHotseat() {
1626 return mHotseat;
1627 }
1628
Jorim Jaggid017f882014-01-14 17:08:48 -08001629 public ViewGroup getOverviewPanel() {
Winson Chunga6945242014-01-08 14:04:34 -08001630 return mOverviewPanel;
1631 }
1632
Sunny Goyal47328fd2016-05-25 18:56:41 -07001633 public DropTargetBar getDropTargetBar() {
1634 return mDropTargetBar;
Tony Wickham34d2c912015-09-11 09:27:58 -07001635 }
1636
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001637 public LauncherAppWidgetHost getAppWidgetHost() {
1638 return mAppWidgetHost;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001639 }
Romain Guycbb89e42009-06-08 15:52:54 -07001640
Winson Chunga9abd0e2010-10-27 17:18:37 -07001641 public LauncherModel getModel() {
1642 return mModel;
1643 }
1644
Sunny Goyal43bf11d2017-02-02 13:52:53 -08001645 public ModelWriter getModelWriter() {
1646 return mModelWriter;
1647 }
1648
Adam Cohen79d90c52016-04-22 13:29:20 -07001649 public SharedPreferences getSharedPrefs() {
Winson Chunga6945242014-01-08 14:04:34 -08001650 return mSharedPrefs;
1651 }
1652
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001653 @Override
1654 protected void onNewIntent(Intent intent) {
Michael Jurka447bf842013-05-15 14:52:15 +02001655 long startTime = 0;
1656 if (DEBUG_RESUME_TIME) {
1657 startTime = System.currentTimeMillis();
1658 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001659 super.onNewIntent(intent);
1660
Winson15f8b172015-08-19 11:02:39 -07001661 boolean alreadyOnHome = mHasFocus && ((intent.getFlags() &
1662 Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT)
1663 != Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT);
Sunny Goyal85313732016-09-28 12:00:07 -07001664
1665 // Check this condition before handling isActionMain, as this will get reset.
1666 boolean shouldMoveToDefaultScreen = alreadyOnHome &&
Sunny Goyal740ac7f2016-09-28 16:47:32 -07001667 mState == State.WORKSPACE && AbstractFloatingView.getTopOpenView(this) == null;
Sunny Goyal85313732016-09-28 12:00:07 -07001668
Winson15f8b172015-08-19 11:02:39 -07001669 boolean isActionMain = Intent.ACTION_MAIN.equals(intent.getAction());
1670 if (isActionMain) {
Adam Cohen6fecd412013-10-02 17:41:50 -07001671 if (mWorkspace == null) {
1672 // Can be cases where mWorkspace is null, this prevents a NPE
1673 return;
1674 }
Jon Mirandafeba90f2016-10-06 10:53:29 -07001675
1676 // Note: There should be at most one log per method call. This is enforced implicitly
1677 // by using if-else statements.
1678 UserEventDispatcher ued = getUserEventDispatcher();
1679
1680 // TODO: Log this case.
Adam Cohen6fecd412013-10-02 17:41:50 -07001681 mWorkspace.exitWidgetResizeMode();
Adam Cohen9211d422014-10-07 18:14:53 -07001682
Jon Mirandafeba90f2016-10-06 10:53:29 -07001683 AbstractFloatingView topOpenView = AbstractFloatingView.getTopOpenView(this);
Tony Wickham540913e2017-01-23 11:47:51 -08001684 if (topOpenView instanceof PopupContainerWithArrow) {
Sunny Goyal6c46a6d2016-11-23 02:24:32 +05301685 ued.logActionCommand(Action.Command.HOME_INTENT,
1686 topOpenView.getExtendedTouchView(), ContainerType.DEEPSHORTCUTS);
Jon Mirandafeba90f2016-10-06 10:53:29 -07001687 } else if (topOpenView instanceof Folder) {
Sunny Goyal6c46a6d2016-11-23 02:24:32 +05301688 ued.logActionCommand(Action.Command.HOME_INTENT,
1689 ((Folder) topOpenView).getFolderIcon(), ContainerType.FOLDER);
Jon Mirandafeba90f2016-10-06 10:53:29 -07001690 } else if (alreadyOnHome) {
Sunny Goyal6c46a6d2016-11-23 02:24:32 +05301691 ued.logActionCommand(Action.Command.HOME_INTENT,
Jon Mirandafeba90f2016-10-06 10:53:29 -07001692 mWorkspace.getState().containerType, mWorkspace.getCurrentPage());
1693 }
1694
1695 // In all these cases, only animate if we're already on home
Sunny Goyal740ac7f2016-09-28 16:47:32 -07001696 AbstractFloatingView.closeAllOpenViews(this, alreadyOnHome);
Adam Cohen6fecd412013-10-02 17:41:50 -07001697 exitSpringLoadedDragMode();
1698
1699 // If we are already on home, then just animate back to the workspace,
1700 // otherwise, just wait until onResume to set the state back to Workspace
1701 if (alreadyOnHome) {
Adam Cohened307df2013-10-02 09:37:31 -07001702 showWorkspace(true);
Adam Cohen6fecd412013-10-02 17:41:50 -07001703 } else {
1704 mOnResumeState = State.WORKSPACE;
1705 }
1706
1707 final View v = getWindow().peekDecorView();
1708 if (v != null && v.getWindowToken() != null) {
Tonyc17390962015-10-25 17:39:37 -07001709 InputMethodManager imm = (InputMethodManager) getSystemService(
Adam Cohen6fecd412013-10-02 17:41:50 -07001710 INPUT_METHOD_SERVICE);
1711 imm.hideSoftInputFromWindow(v.getWindowToken(), 0);
1712 }
1713
Winson Chungb745afb2015-03-02 11:51:23 -08001714 // Reset the apps view
1715 if (!alreadyOnHome && mAppsView != null) {
Sunny Goyal161f96b2017-05-07 11:56:00 -07001716 mAppsView.reset();
Winson Chungb745afb2015-03-02 11:51:23 -08001717 }
1718
Hyunyoung Song3f471442015-04-08 19:01:34 -07001719 // Reset the widgets view
1720 if (!alreadyOnHome && mWidgetsView != null) {
1721 mWidgetsView.scrollToTop();
Adam Cohen6fecd412013-10-02 17:41:50 -07001722 }
Adam Coppa120b8e2013-11-12 16:26:04 +00001723
Adam Cohen9211d422014-10-07 18:14:53 -07001724 if (mLauncherCallbacks != null) {
1725 mLauncherCallbacks.onHomeIntent();
1726 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001727 }
Sunny Goyal5a81c382017-03-20 15:08:06 -07001728 PinItemDragListener.handleDragRequest(this, intent);
Adam Cohened307df2013-10-02 09:37:31 -07001729
Adam Cohen9211d422014-10-07 18:14:53 -07001730 if (mLauncherCallbacks != null) {
1731 mLauncherCallbacks.onNewIntent(intent);
1732 }
Winson15f8b172015-08-19 11:02:39 -07001733
1734 // Defer moving to the default screen until after we callback to the LauncherCallbacks
1735 // as slow logic in the callbacks eat into the time the scroller expects for the snapToPage
1736 // animation.
1737 if (isActionMain) {
Sunny Goyal85313732016-09-28 12:00:07 -07001738 boolean callbackAllowsMoveToDefaultScreen = mLauncherCallbacks != null ?
Ivan Lee667d6882015-09-03 10:16:07 -06001739 mLauncherCallbacks.shouldMoveToDefaultScreenOnHomeIntent() : true;
Sunny Goyal85313732016-09-28 12:00:07 -07001740 if (shouldMoveToDefaultScreen && !mWorkspace.isTouchActive()
1741 && callbackAllowsMoveToDefaultScreen) {
Adam Cohen4b66bf32015-09-18 12:15:19 -07001742
1743 // We use this flag to suppress noisy callbacks above custom content state
1744 // from onResume.
1745 mMoveToDefaultScreenFromNewIntent = true;
Winson15f8b172015-08-19 11:02:39 -07001746 mWorkspace.post(new Runnable() {
1747 @Override
1748 public void run() {
Tonyc17390962015-10-25 17:39:37 -07001749 if (mWorkspace != null) {
1750 mWorkspace.moveToDefaultScreen(true);
1751 }
Winson15f8b172015-08-19 11:02:39 -07001752 }
1753 });
1754 }
1755 }
1756
1757 if (DEBUG_RESUME_TIME) {
1758 Log.d(TAG, "Time spent in onNewIntent: " + (System.currentTimeMillis() - startTime));
1759 }
Adam Coppa120b8e2013-11-12 16:26:04 +00001760 }
1761
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001762 @Override
Adam Cohen1462de32012-07-24 22:34:36 -07001763 public void onRestoreInstanceState(Bundle state) {
1764 super.onRestoreInstanceState(state);
1765 for (int page: mSynchronouslyBoundPages) {
1766 mWorkspace.restoreInstanceStateForChild(page);
1767 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001768 }
1769
1770 @Override
1771 protected void onSaveInstanceState(Bundle outState) {
Adam Cohen21cd0022013-10-09 18:57:02 -07001772 if (mWorkspace.getChildCount() > 0) {
Winson Chung9b9fb962013-11-15 15:39:34 -08001773 outState.putInt(RUNTIME_STATE_CURRENT_SCREEN,
1774 mWorkspace.getCurrentPageOffsetFromCustomContent());
Hyunyoung Song645764e2016-06-06 14:19:02 -07001775
Adam Cohen21cd0022013-10-09 18:57:02 -07001776 }
Adam Cohen95bb8002011-07-03 23:40:28 -07001777 super.onSaveInstanceState(outState);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001778
Michael Jurka883f55b2010-10-21 15:47:14 -07001779 outState.putInt(RUNTIME_STATE, mState.ordinal());
Sunny Goyal740ac7f2016-09-28 16:47:32 -07001780 // We close any open folders and shortcut containers since they will not be re-opened,
1781 // and we need to make sure this state is reflected.
1782 AbstractFloatingView.closeAllOpenViews(this, false);
Tony Wickham49c8d292016-07-01 11:44:34 -07001783
Sunny Goyal2100c782016-08-22 16:00:03 -07001784 if (mPendingRequestArgs != null) {
1785 outState.putParcelable(RUNTIME_STATE_PENDING_REQUEST_ARGS, mPendingRequestArgs);
1786 }
1787 if (mPendingActivityResult != null) {
1788 outState.putParcelable(RUNTIME_STATE_PENDING_ACTIVITY_RESULT, mPendingActivityResult);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001789 }
1790
Adam Cohen9211d422014-10-07 18:14:53 -07001791 if (mLauncherCallbacks != null) {
1792 mLauncherCallbacks.onSaveInstanceState(outState);
1793 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001794 }
1795
1796 @Override
1797 public void onDestroy() {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001798 super.onDestroy();
Romain Guycbb89e42009-06-08 15:52:54 -07001799
Michael Jurka9d906c72011-10-14 06:25:36 -07001800 mWorkspace.removeCallbacks(mBuildLayersRunnable);
Sunny Goyalaaf7d1d2016-05-17 13:38:54 -07001801 mWorkspace.removeFolderListeners();
Winson Chunge7a03942011-08-05 15:05:12 -07001802
Winson Chungcd2b0142011-06-08 16:02:26 -07001803 // Stop callbacks from LauncherModel
Adam Cohen1a85c582014-09-30 09:48:49 -07001804 // It's possible to receive onDestroy after a new Launcher activity has
1805 // been created. In this case, don't interfere with the new Launcher.
1806 if (mModel.isCurrentCallbacks(this)) {
1807 mModel.stopLoader();
Sunny Goyal87f784c2017-01-11 10:48:34 -08001808 LauncherAppState.getInstance(this).setLauncher(null);
Adam Cohen1a85c582014-09-30 09:48:49 -07001809 }
Winson Chungcd2b0142011-06-08 16:02:26 -07001810
Sunny Goyal745bad92016-05-02 10:54:12 -07001811 if (mRotationPrefChangeHandler != null) {
1812 mSharedPrefs.unregisterOnSharedPreferenceChangeListener(mRotationPrefChangeHandler);
1813 }
1814
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001815 try {
The Android Open Source Project7376fae2009-03-11 12:11:58 -07001816 mAppWidgetHost.stopListening();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001817 } catch (NullPointerException ex) {
Joe Onoratoa30ce8e2009-11-11 08:16:49 -08001818 Log.w(TAG, "problem while stopping AppWidgetHost during Launcher destruction", ex);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001819 }
Patrick Dubroy2313eff2011-01-11 20:01:31 -08001820 mAppWidgetHost = null;
1821
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001822 TextKeyListener.getInstance().release();
1823
Tony Wickhame2217252016-03-22 16:34:23 -07001824 ((AccessibilityManager) getSystemService(ACCESSIBILITY_SERVICE))
1825 .removeAccessibilityStateChangeListener(this);
1826
Michael Jurka2ecf9952012-06-18 12:52:28 -07001827 LauncherAnimUtils.onDestroyActivity();
Adam Cohen9211d422014-10-07 18:14:53 -07001828
1829 if (mLauncherCallbacks != null) {
1830 mLauncherCallbacks.onDestroy();
1831 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001832 }
1833
Sunny Goyalae502842016-06-17 08:43:56 -07001834 public LauncherAccessibilityDelegate getAccessibilityDelegate() {
1835 return mAccessibilityDelegate;
1836 }
1837
Adam Cohena9cf38f2011-05-02 15:36:58 -07001838 public DragController getDragController() {
1839 return mDragController;
1840 }
1841
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001842 @Override
Sunny Goyal0eca4e22016-07-20 11:43:06 -07001843 public void startActivityForResult(Intent intent, int requestCode, Bundle options) {
Sunny Goyal0eca4e22016-07-20 11:43:06 -07001844 super.startActivityForResult(intent, requestCode, options);
Adam Cohen173f7112015-03-27 15:14:00 -07001845 }
1846
1847 @Override
1848 public void startIntentSenderForResult (IntentSender intent, int requestCode,
1849 Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags, Bundle options) {
Adam Cohen173f7112015-03-27 15:14:00 -07001850 try {
1851 super.startIntentSenderForResult(intent, requestCode,
1852 fillInIntent, flagsMask, flagsValues, extraFlags, options);
1853 } catch (IntentSender.SendIntentException e) {
1854 throw new ActivityNotFoundException();
1855 }
1856 }
1857
Winson Chung70d72102011-08-12 11:24:35 -07001858 /**
1859 * Indicates that we want global search for this activity by setting the globalSearch
1860 * argument for {@link #startSearch} to true.
1861 */
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001862 @Override
Romain Guycbb89e42009-06-08 15:52:54 -07001863 public void startSearch(String initialQuery, boolean selectInitialQuery,
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001864 Bundle appSearchData, boolean globalSearch) {
Karl Rosaen138a0412009-04-23 19:00:21 -07001865
Karl Rosaen138a0412009-04-23 19:00:21 -07001866 if (initialQuery == null) {
1867 // Use any text typed in the launcher as the initial query
1868 initialQuery = getTypedText();
Karl Rosaen138a0412009-04-23 19:00:21 -07001869 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001870 if (appSearchData == null) {
1871 appSearchData = new Bundle();
Bjorn Bringert32b12d22013-06-06 13:00:41 +01001872 appSearchData.putString("source", "launcher-search");
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001873 }
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07001874
Sunny Goyal6f28e712016-09-13 14:19:29 -07001875 if (mLauncherCallbacks == null ||
1876 !mLauncherCallbacks.startSearch(initialQuery, selectInitialQuery, appSearchData)) {
1877 // Starting search from the callbacks failed. Start the default global search.
1878 startGlobalSearch(initialQuery, selectInitialQuery, appSearchData, null);
Ian Parkinson047036e2014-09-01 15:40:53 +01001879 }
Winson Chungcd99cd32015-04-29 11:03:24 -07001880
1881 // We need to show the workspace after starting the search
1882 showWorkspace(true);
Bjorn Bringertc459e522013-06-07 19:36:01 +01001883 }
1884
Ian Parkinson047036e2014-09-01 15:40:53 +01001885 /**
Michael Jurkaa33411c2012-06-14 16:18:21 -07001886 * Starts the global search activity. This code is a copied from SearchManager
1887 */
Sunny Goyal6f28e712016-09-13 14:19:29 -07001888 public void startGlobalSearch(String initialQuery,
Michael Jurkaa33411c2012-06-14 16:18:21 -07001889 boolean selectInitialQuery, Bundle appSearchData, Rect sourceBounds) {
Karl Rosaen138a0412009-04-23 19:00:21 -07001890 final SearchManager searchManager =
Michael Jurkaa33411c2012-06-14 16:18:21 -07001891 (SearchManager) getSystemService(Context.SEARCH_SERVICE);
1892 ComponentName globalSearchActivity = searchManager.getGlobalSearchActivity();
1893 if (globalSearchActivity == null) {
1894 Log.w(TAG, "No global search activity found.");
1895 return;
1896 }
1897 Intent intent = new Intent(SearchManager.INTENT_ACTION_GLOBAL_SEARCH);
1898 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
1899 intent.setComponent(globalSearchActivity);
1900 // Make sure that we have a Bundle to put source in
1901 if (appSearchData == null) {
1902 appSearchData = new Bundle();
1903 } else {
1904 appSearchData = new Bundle(appSearchData);
1905 }
Adam Cohen9211d422014-10-07 18:14:53 -07001906 // Set source to package name of app that starts global search if not set already.
Michael Jurkaa33411c2012-06-14 16:18:21 -07001907 if (!appSearchData.containsKey("source")) {
1908 appSearchData.putString("source", getPackageName());
1909 }
1910 intent.putExtra(SearchManager.APP_DATA, appSearchData);
1911 if (!TextUtils.isEmpty(initialQuery)) {
1912 intent.putExtra(SearchManager.QUERY, initialQuery);
1913 }
1914 if (selectInitialQuery) {
1915 intent.putExtra(SearchManager.EXTRA_SELECT_QUERY, selectInitialQuery);
1916 }
1917 intent.setSourceBounds(sourceBounds);
1918 try {
1919 startActivity(intent);
1920 } catch (ActivityNotFoundException ex) {
1921 Log.e(TAG, "Global search activity not found: " + globalSearchActivity);
1922 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001923 }
1924
Yura4f93ec62014-02-04 14:15:21 +00001925 public boolean isOnCustomContent() {
1926 return mWorkspace.isOnOrMovingToCustomContent();
1927 }
1928
Winson Chung70d72102011-08-12 11:24:35 -07001929 @Override
Winson Chung70d72102011-08-12 11:24:35 -07001930 public boolean onPrepareOptionsMenu(Menu menu) {
1931 super.onPrepareOptionsMenu(menu);
Adam Cohen9211d422014-10-07 18:14:53 -07001932 if (mLauncherCallbacks != null) {
1933 return mLauncherCallbacks.onPrepareOptionsMenu(menu);
1934 }
Michael Jurkab94f3f82013-09-11 18:08:54 +02001935 return false;
Winson Chung70d72102011-08-12 11:24:35 -07001936 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001937
The Android Open Source Projectca9475f2009-03-13 13:04:24 -07001938 @Override
1939 public boolean onSearchRequested() {
Romain Guycbb89e42009-06-08 15:52:54 -07001940 startSearch(null, false, null, true);
Amith Yamasania135ba82011-08-09 17:42:01 -07001941 // Use a custom animation for launching search
Karl Rosaen138a0412009-04-23 19:00:21 -07001942 return true;
The Android Open Source Projectca9475f2009-03-13 13:04:24 -07001943 }
1944
Joe Onorato9c1289c2009-08-17 11:03:03 -04001945 public boolean isWorkspaceLocked() {
Sunny Goyal2100c782016-08-22 16:00:03 -07001946 return mWorkspaceLoading || mPendingRequestArgs != null;
Joe Onorato9c1289c2009-08-17 11:03:03 -04001947 }
1948
Adam Cohen517a7f52014-03-01 12:12:59 -08001949 public boolean isWorkspaceLoading() {
1950 return mWorkspaceLoading;
1951 }
1952
Anjali Koppalff7ceff2014-05-01 18:26:37 -07001953 private void setWorkspaceLoading(boolean value) {
1954 boolean isLocked = isWorkspaceLocked();
1955 mWorkspaceLoading = value;
1956 if (isLocked != isWorkspaceLocked()) {
1957 onWorkspaceLockedChanged();
1958 }
1959 }
1960
Sunny Goyal04a324a2017-01-20 21:08:59 -08001961 public void setWaitingForResult(PendingRequestArgs args) {
Anjali Koppalff7ceff2014-05-01 18:26:37 -07001962 boolean isLocked = isWorkspaceLocked();
Sunny Goyal2100c782016-08-22 16:00:03 -07001963 mPendingRequestArgs = args;
Anjali Koppalff7ceff2014-05-01 18:26:37 -07001964 if (isLocked != isWorkspaceLocked()) {
1965 onWorkspaceLockedChanged();
1966 }
1967 }
1968
Adam Cohen9211d422014-10-07 18:14:53 -07001969 protected void onWorkspaceLockedChanged() {
1970 if (mLauncherCallbacks != null) {
1971 mLauncherCallbacks.onWorkspaceLockedChanged();
1972 }
1973 }
Anjali Koppalff7ceff2014-05-01 18:26:37 -07001974
Sunny Goyal2100c782016-08-22 16:00:03 -07001975 void addAppWidgetFromDropImpl(int appWidgetId, ItemInfo info, AppWidgetHostView boundWidget,
Sunny Goyal04a324a2017-01-20 21:08:59 -08001976 WidgetAddFlowHandler addFlowHandler) {
Tony Wickhama0628cc2015-10-14 15:23:04 -07001977 if (LOGD) {
1978 Log.d(TAG, "Adding widget from drop");
1979 }
Sunny Goyal04a324a2017-01-20 21:08:59 -08001980 addAppWidgetImpl(appWidgetId, info, boundWidget, addFlowHandler, 0);
Adam Cohenad4e15c2013-10-17 16:21:35 -07001981 }
1982
Sunny Goyal2100c782016-08-22 16:00:03 -07001983 void addAppWidgetImpl(int appWidgetId, ItemInfo info,
Sunny Goyal04a324a2017-01-20 21:08:59 -08001984 AppWidgetHostView boundWidget, WidgetAddFlowHandler addFlowHandler, int delay) {
1985 if (!addFlowHandler.startConfigActivity(this, appWidgetId, info, REQUEST_CREATE_APPWIDGET)) {
1986 // If the configuration flow was not started, add the widget
Michael Jurkaaf442092010-06-10 17:01:57 -07001987
Adam Cohenad4e15c2013-10-17 16:21:35 -07001988 Runnable onComplete = new Runnable() {
1989 @Override
1990 public void run() {
1991 // Exit spring loaded mode if necessary after adding the widget
1992 exitSpringLoadedDragModeDelayed(true, EXIT_SPRINGLOADED_MODE_SHORT_TIMEOUT,
1993 null);
1994 }
1995 };
Sunny Goyal04a324a2017-01-20 21:08:59 -08001996 completeAddAppWidget(appWidgetId, info, boundWidget, addFlowHandler.getProviderInfo(this));
Adam Cohen689ff162014-05-08 17:27:56 -07001997 mWorkspace.removeExtraEmptyScreenDelayed(true, onComplete, delay, false);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001998 }
1999 }
Romain Guycbb89e42009-06-08 15:52:54 -07002000
Allan Wojciechowskiaf110e82013-09-12 10:48:23 +01002001 protected void moveToCustomContentScreen(boolean animate) {
Sandeep Siddharthaf2b47f12013-09-26 19:49:27 -07002002 // Close any folders that may be open.
Sunny Goyal740ac7f2016-09-28 16:47:32 -07002003 AbstractFloatingView.closeAllOpenViews(this, animate);
Allan Wojciechowskiaf110e82013-09-12 10:48:23 +01002004 mWorkspace.moveToCustomContentScreen(animate);
2005 }
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08002006
2007 public void addPendingItem(PendingAddItemInfo info, long container, long screenId,
2008 int[] cell, int spanX, int spanY) {
Sunny Goyal2100c782016-08-22 16:00:03 -07002009 info.container = container;
2010 info.screenId = screenId;
2011 if (cell != null) {
2012 info.cellX = cell[0];
2013 info.cellY = cell[1];
2014 }
2015 info.spanX = spanX;
2016 info.spanY = spanY;
2017
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08002018 switch (info.itemType) {
2019 case LauncherSettings.Favorites.ITEM_TYPE_CUSTOM_APPWIDGET:
2020 case LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET:
Sunny Goyal2100c782016-08-22 16:00:03 -07002021 addAppWidgetFromDrop((PendingAddWidgetInfo) info);
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08002022 break;
2023 case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT:
Sunny Goyal782f0c92017-01-19 10:27:54 -08002024 processShortcutFromDrop((PendingAddShortcutInfo) info);
Sunny Goyal71b5c0b2015-01-08 16:59:04 -08002025 break;
2026 default:
2027 throw new IllegalStateException("Unknown item type: " + info.itemType);
2028 }
2029 }
2030
Adam Cohenfbba09b2011-07-18 21:43:05 -07002031 /**
2032 * Process a shortcut drop.
Adam Cohenfbba09b2011-07-18 21:43:05 -07002033 */
Sunny Goyal782f0c92017-01-19 10:27:54 -08002034 private void processShortcutFromDrop(PendingAddShortcutInfo info) {
Sunny Goyalfb5096d2016-09-08 14:32:06 -07002035 Intent intent = new Intent(Intent.ACTION_CREATE_SHORTCUT).setComponent(info.componentName);
2036 setWaitingForResult(PendingRequestArgs.forIntent(REQUEST_CREATE_SHORTCUT, intent, info));
Sunny Goyal782f0c92017-01-19 10:27:54 -08002037 if (!info.activityInfo.startConfigActivity(this, REQUEST_CREATE_SHORTCUT)) {
2038 handleActivityResult(REQUEST_CREATE_SHORTCUT, RESULT_CANCELED, null);
2039 }
Michael Jurka0280c3b2010-09-17 15:00:07 -07002040 }
2041
Adam Cohenfbba09b2011-07-18 21:43:05 -07002042 /**
2043 * Process a widget drop.
Adam Cohenfbba09b2011-07-18 21:43:05 -07002044 */
Sunny Goyal2100c782016-08-22 16:00:03 -07002045 private void addAppWidgetFromDrop(PendingAddWidgetInfo info) {
Adam Cohened66b2b2012-01-23 17:28:51 -08002046 AppWidgetHostView hostView = info.boundWidget;
2047 int appWidgetId;
Sunny Goyal8a0dc382017-01-25 11:30:06 -08002048 WidgetAddFlowHandler addFlowHandler = info.getHandler();
Adam Cohened66b2b2012-01-23 17:28:51 -08002049 if (hostView != null) {
Tony Wickhama0628cc2015-10-14 15:23:04 -07002050 // In the case where we've prebound the widget, we remove it from the DragLayer
2051 if (LOGD) {
2052 Log.d(TAG, "Removing widget view from drag layer and setting boundWidget to null");
2053 }
2054 getDragLayer().removeView(hostView);
2055
Adam Cohened66b2b2012-01-23 17:28:51 -08002056 appWidgetId = hostView.getAppWidgetId();
Sunny Goyal04a324a2017-01-20 21:08:59 -08002057 addAppWidgetFromDropImpl(appWidgetId, info, hostView, addFlowHandler);
Sunny Goyal5b9ebca2015-06-01 18:37:32 -07002058
2059 // Clear the boundWidget so that it doesn't get destroyed.
2060 info.boundWidget = null;
Adam Cohened66b2b2012-01-23 17:28:51 -08002061 } else {
Adam Cohen9d5b7d82012-05-09 18:00:44 -07002062 // In this case, we either need to start an activity to get permission to bind
2063 // the widget, or we need to start an activity to configure the widget, or both.
Adam Cohened66b2b2012-01-23 17:28:51 -08002064 appWidgetId = getAppWidgetHost().allocateAppWidgetId();
Adam Cohendd70d662012-10-04 16:53:44 -07002065 Bundle options = info.bindOptions;
2066
Sunny Goyalffe83f12014-08-14 17:39:34 -07002067 boolean success = mAppWidgetManager.bindAppWidgetIdIfAllowed(
2068 appWidgetId, info.info, options);
Adam Cohendd70d662012-10-04 16:53:44 -07002069 if (success) {
Sunny Goyal04a324a2017-01-20 21:08:59 -08002070 addAppWidgetFromDropImpl(appWidgetId, info, null, addFlowHandler);
Michael Jurka8b805b12012-04-18 14:23:14 -07002071 } else {
Sunny Goyal04a324a2017-01-20 21:08:59 -08002072 addFlowHandler.startBindFlow(this, appWidgetId, info, REQUEST_BIND_APPWIDGET);
Michael Jurka8b805b12012-04-18 14:23:14 -07002073 }
Adam Cohened66b2b2012-01-23 17:28:51 -08002074 }
Adam Cohenfbba09b2011-07-18 21:43:05 -07002075 }
2076
Adam Cohendcd297f2013-06-18 13:13:40 -07002077 FolderIcon addFolder(CellLayout layout, long container, final long screenId, int cellX,
Winson Chung3d503fb2011-07-13 17:25:49 -07002078 int cellY) {
Michael Jurkac9d95c52011-08-29 14:03:34 -07002079 final FolderInfo folderInfo = new FolderInfo();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002080 folderInfo.title = getText(R.string.folder_name);
2081
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002082 // Update the model
Sunny Goyal43bf11d2017-02-02 13:52:53 -08002083 getModelWriter().addItemToDatabase(folderInfo, container, screenId, cellX, cellY);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002084
2085 // Create the view
Sunny Goyal1cd01b02016-11-09 10:43:58 -08002086 FolderIcon newFolder = FolderIcon.fromXml(R.layout.folder_icon, this, layout, folderInfo);
Sunny Goyald5462aa2016-11-22 16:52:39 +05302087 mWorkspace.addInScreen(newFolder, folderInfo);
Winson Chung5f8afe62013-08-12 16:19:28 -07002088 // Force measure the new folder icon
2089 CellLayout parent = mWorkspace.getParentCellLayoutForView(newFolder);
2090 parent.getShortcutsAndWidgets().measureChild(newFolder);
Adam Cohendf035382011-04-11 17:22:04 -07002091 return newFolder;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002092 }
Romain Guycbb89e42009-06-08 15:52:54 -07002093
Winsonc0b52fe2015-09-09 16:38:15 -07002094 /**
Winsonfa56b3f2015-09-14 12:01:13 -07002095 * Unbinds the view for the specified item, and removes the item and all its children.
2096 *
2097 * @param v the view being removed.
Winsonfa56b3f2015-09-14 12:01:13 -07002098 * @param itemInfo the {@link ItemInfo} for this view.
2099 * @param deleteFromDb whether or not to delete this item from the db.
Winsonc0b52fe2015-09-09 16:38:15 -07002100 */
Tony Wickhambfbf7f92016-05-19 11:19:39 -07002101 public boolean removeItem(View v, final ItemInfo itemInfo, boolean deleteFromDb) {
Winsonc0b52fe2015-09-09 16:38:15 -07002102 if (itemInfo instanceof ShortcutInfo) {
Winsonfa56b3f2015-09-14 12:01:13 -07002103 // Remove the shortcut from the folder before removing it from launcher
Sunny Goyal44c06432016-04-02 10:56:02 -07002104 View folderIcon = mWorkspace.getHomescreenIconByItemId(itemInfo.container);
2105 if (folderIcon instanceof FolderIcon) {
Sunny Goyalc52ba712016-04-05 15:59:05 -07002106 ((FolderInfo) folderIcon.getTag()).remove((ShortcutInfo) itemInfo, true);
Winsonfa56b3f2015-09-14 12:01:13 -07002107 } else {
2108 mWorkspace.removeWorkspaceItem(v);
2109 }
Winsonc0b52fe2015-09-09 16:38:15 -07002110 if (deleteFromDb) {
Sunny Goyal43bf11d2017-02-02 13:52:53 -08002111 getModelWriter().deleteItemFromDatabase(itemInfo);
Winsonc0b52fe2015-09-09 16:38:15 -07002112 }
2113 } else if (itemInfo instanceof FolderInfo) {
2114 final FolderInfo folderInfo = (FolderInfo) itemInfo;
Sunny Goyalaaf7d1d2016-05-17 13:38:54 -07002115 if (v instanceof FolderIcon) {
2116 ((FolderIcon) v).removeListeners();
2117 }
Winsonc0b52fe2015-09-09 16:38:15 -07002118 mWorkspace.removeWorkspaceItem(v);
2119 if (deleteFromDb) {
Sunny Goyal43bf11d2017-02-02 13:52:53 -08002120 getModelWriter().deleteFolderAndContentsFromDatabase(folderInfo);
Winsonc0b52fe2015-09-09 16:38:15 -07002121 }
2122 } else if (itemInfo instanceof LauncherAppWidgetInfo) {
2123 final LauncherAppWidgetInfo widgetInfo = (LauncherAppWidgetInfo) itemInfo;
Winson44818e02015-10-02 11:25:46 -07002124 mWorkspace.removeWorkspaceItem(v);
Winsonc0b52fe2015-09-09 16:38:15 -07002125 if (deleteFromDb) {
Sunny Goyal56c73602015-09-25 12:55:01 -07002126 deleteWidgetInfo(widgetInfo);
Winsonc0b52fe2015-09-09 16:38:15 -07002127 }
2128 } else {
2129 return false;
2130 }
2131 return true;
2132 }
2133
2134 /**
Sunny Goyal56c73602015-09-25 12:55:01 -07002135 * Deletes the widget info and the widget id.
Winsonc0b52fe2015-09-09 16:38:15 -07002136 */
Sunny Goyal56c73602015-09-25 12:55:01 -07002137 private void deleteWidgetInfo(final LauncherAppWidgetInfo widgetInfo) {
Winsonc0b52fe2015-09-09 16:38:15 -07002138 final LauncherAppWidgetHost appWidgetHost = getAppWidgetHost();
Sunny Goyald478c832016-04-01 12:04:16 -07002139 if (appWidgetHost != null && !widgetInfo.isCustomWidget() && widgetInfo.isWidgetIdAllocated()) {
Winsonc0b52fe2015-09-09 16:38:15 -07002140 // Deleting an app widget ID is a void call but writes to disk before returning
2141 // to the caller...
2142 new AsyncTask<Void, Void, Void>() {
2143 public Void doInBackground(Void ... args) {
2144 appWidgetHost.deleteAppWidgetId(widgetInfo.appWidgetId);
2145 return null;
2146 }
Sunny Goyalf27cb0e2015-09-23 16:12:02 -07002147 }.executeOnExecutor(Utilities.THREAD_POOL_EXECUTOR);
Winsonc0b52fe2015-09-09 16:38:15 -07002148 }
Sunny Goyal43bf11d2017-02-02 13:52:53 -08002149 getModelWriter().deleteItemFromDatabase(widgetInfo);
Winsonc0b52fe2015-09-09 16:38:15 -07002150 }
2151
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002152 @Override
2153 public boolean dispatchKeyEvent(KeyEvent event) {
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08002154 return (event.getKeyCode() == KeyEvent.KEYCODE_HOME) || super.dispatchKeyEvent(event);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002155 }
2156
Joe Onorato88ec0992009-11-19 13:16:06 -08002157 @Override
2158 public void onBackPressed() {
Adam Cohen9211d422014-10-07 18:14:53 -07002159 if (mLauncherCallbacks != null && mLauncherCallbacks.handleBackPressed()) {
2160 return;
2161 }
2162
Sunny Goyal45478022015-06-08 16:52:41 -07002163 if (mDragController.isDragging()) {
2164 mDragController.cancelDrag();
Adam Cohenc9735cf2015-01-23 16:11:55 -08002165 return;
2166 }
2167
Jon Mirandafeba90f2016-10-06 10:53:29 -07002168 // Note: There should be at most one log per method call. This is enforced implicitly
2169 // by using if-else statements.
2170 UserEventDispatcher ued = getUserEventDispatcher();
Sunny Goyal740ac7f2016-09-28 16:47:32 -07002171 AbstractFloatingView topView = AbstractFloatingView.getTopOpenView(this);
2172 if (topView != null) {
2173 if (topView.getActiveTextView() != null) {
2174 topView.getActiveTextView().dispatchBackKey();
2175 } else {
Tony Wickham540913e2017-01-23 11:47:51 -08002176 if (topView instanceof PopupContainerWithArrow) {
Sunny Goyal6c46a6d2016-11-23 02:24:32 +05302177 ued.logActionCommand(Action.Command.BACK,
2178 topView.getExtendedTouchView(), ContainerType.DEEPSHORTCUTS);
Jon Mirandafeba90f2016-10-06 10:53:29 -07002179 } else if (topView instanceof Folder) {
Sunny Goyal6c46a6d2016-11-23 02:24:32 +05302180 ued.logActionCommand(Action.Command.BACK,
2181 ((Folder) topView).getFolderIcon(), ContainerType.FOLDER);
Jon Mirandafeba90f2016-10-06 10:53:29 -07002182 }
Sunny Goyal740ac7f2016-09-28 16:47:32 -07002183 topView.close(true);
2184 }
Tony Wickham49c8d292016-07-01 11:44:34 -07002185 } else if (isAppsViewVisible()) {
Sunny Goyal6c46a6d2016-11-23 02:24:32 +05302186 ued.logActionCommand(Action.Command.BACK, ContainerType.ALLAPPS);
Winson Chungb745afb2015-03-02 11:51:23 -08002187 showWorkspace(true);
2188 } else if (isWidgetsViewVisible()) {
Sunny Goyal6c46a6d2016-11-23 02:24:32 +05302189 ued.logActionCommand(Action.Command.BACK, ContainerType.WIDGETS);
Winson Chungb745afb2015-03-02 11:51:23 -08002190 showOverviewMode(true);
Adam Cohenf358a4b2013-07-23 16:47:31 -07002191 } else if (mWorkspace.isInOverviewMode()) {
Sunny Goyal6c46a6d2016-11-23 02:24:32 +05302192 ued.logActionCommand(Action.Command.BACK, ContainerType.OVERVIEW);
Winson Chungdc61c4d2015-04-20 18:26:57 -07002193 showWorkspace(true);
Patrick Dubroy94f78a52011-02-28 17:39:16 -08002194 } else {
Jon Mirandafeba90f2016-10-06 10:53:29 -07002195 // TODO: Log this case.
Patrick Dubroy758a9232011-03-03 19:54:56 -08002196 mWorkspace.exitWidgetResizeMode();
2197
Patrick Dubroy94f78a52011-02-28 17:39:16 -08002198 // Back button is a no-op here, but give at least some feedback for the button press
2199 mWorkspace.showOutlinesTemporarily();
Michael Jurkaaf442092010-06-10 17:01:57 -07002200 }
Joe Onorato88ec0992009-11-19 13:16:06 -08002201 }
2202
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002203 /**
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002204 * Launches the intent referred by the clicked shortcut.
2205 *
2206 * @param v The view representing the clicked shortcut.
2207 */
2208 public void onClick(View v) {
Adam Cohen9932a9b2011-08-02 22:14:07 -07002209 // Make sure that rogue clicks don't get through while allapps is launching, or after the
2210 // view has detached (it's possible for this to happen if the view is removed mid touch).
2211 if (v.getWindowToken() == null) {
2212 return;
2213 }
2214
Winson Chung9b0b2fe2012-02-24 13:03:34 -08002215 if (!mWorkspace.isFinishedSwitchingState()) {
Adam Cohen9932a9b2011-08-02 22:14:07 -07002216 return;
2217 }
Adam Cohen2f84ef22011-07-26 17:16:44 -07002218
Adam Cohen1697b792013-09-17 19:08:21 -07002219 if (v instanceof Workspace) {
2220 if (mWorkspace.isInOverviewMode()) {
Jon Miranda2e61fba2017-02-24 09:12:59 -08002221 getUserEventDispatcher().logActionOnContainer(LauncherLogProto.Action.Type.TOUCH,
2222 LauncherLogProto.Action.Direction.NONE,
2223 LauncherLogProto.ContainerType.OVERVIEW, mWorkspace.getCurrentPage());
Winson Chungdc61c4d2015-04-20 18:26:57 -07002224 showWorkspace(true);
Adam Cohenf358a4b2013-07-23 16:47:31 -07002225 }
2226 return;
2227 }
2228
2229 if (v instanceof CellLayout) {
2230 if (mWorkspace.isInOverviewMode()) {
Jon Mirandac6cf4932017-02-07 17:12:36 -08002231 int page = mWorkspace.indexOfChild(v);
2232 getUserEventDispatcher().logActionOnContainer(LauncherLogProto.Action.Type.TOUCH,
2233 LauncherLogProto.Action.Direction.NONE,
2234 LauncherLogProto.ContainerType.OVERVIEW, page);
2235 mWorkspace.snapToPageFromOverView(page);
Sunny Goyalce5a7e52015-07-08 15:44:27 -07002236 showWorkspace(true);
Adam Cohenf358a4b2013-07-23 16:47:31 -07002237 }
Sunny Goyalce5a7e52015-07-08 15:44:27 -07002238 return;
Adam Cohenf358a4b2013-07-23 16:47:31 -07002239 }
2240
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002241 Object tag = v.getTag();
Joe Onorato0589f0f2010-02-08 13:44:00 -08002242 if (tag instanceof ShortcutInfo) {
Sandeep Siddharthaa9420302014-02-12 18:24:31 -08002243 onClickAppShortcut(v);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002244 } else if (tag instanceof FolderInfo) {
Adam Cohena9cf38f2011-05-02 15:36:58 -07002245 if (v instanceof FolderIcon) {
Sandeep Siddharthaa9420302014-02-12 18:24:31 -08002246 onClickFolderIcon(v);
Adam Cohena9cf38f2011-05-02 15:36:58 -07002247 }
Hyunyoung Song68f98ac2016-07-22 14:22:49 -07002248 } else if ((FeatureFlags.LAUNCHER3_ALL_APPS_PULL_UP && v instanceof PageIndicator) ||
2249 (v == mAllAppsButton && mAllAppsButton != null)) {
Sandeep Siddharthaa9420302014-02-12 18:24:31 -08002250 onClickAllAppsButton(v);
Sunny Goyal508da152014-08-14 10:53:27 -07002251 } else if (tag instanceof AppInfo) {
2252 startAppShortcutOrInfoActivity(v);
Sunny Goyalff572272014-07-23 13:58:07 -07002253 } else if (tag instanceof LauncherAppWidgetInfo) {
2254 if (v instanceof PendingAppWidgetHostView) {
2255 onClickPendingWidget((PendingAppWidgetHostView) v);
2256 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002257 }
2258 }
2259
Sunny Goyal70660032015-05-14 00:07:08 -07002260 @SuppressLint("ClickableViewAccessibility")
Michael Jurka0e260592010-06-30 17:07:39 -07002261 public boolean onTouch(View v, MotionEvent event) {
Michael Jurka0e260592010-06-30 17:07:39 -07002262 return false;
2263 }
2264
Michael Jurkaaf442092010-06-10 17:01:57 -07002265 /**
Sunny Goyalff572272014-07-23 13:58:07 -07002266 * Event handler for the app widget view which has not fully restored.
2267 */
Sunny Goyale7b8cd92014-08-27 14:04:33 -07002268 public void onClickPendingWidget(final PendingAppWidgetHostView v) {
Sunny Goyal9b4b0812014-10-08 10:47:28 -07002269 if (mIsSafeModeEnabled) {
2270 Toast.makeText(this, R.string.safemode_widget_error, Toast.LENGTH_SHORT).show();
2271 return;
2272 }
2273
Sunny Goyale7b8cd92014-08-27 14:04:33 -07002274 final LauncherAppWidgetInfo info = (LauncherAppWidgetInfo) v.getTag();
Sunny Goyalff572272014-07-23 13:58:07 -07002275 if (v.isReadyForClickSetup()) {
Sunny Goyal04a324a2017-01-20 21:08:59 -08002276 LauncherAppWidgetProviderInfo appWidgetInfo =
2277 mAppWidgetManager.findProvider(info.providerName, info.user);
2278 if (appWidgetInfo == null) {
2279 return;
2280 }
2281 WidgetAddFlowHandler addFlowHandler = new WidgetAddFlowHandler(appWidgetInfo);
2282
Sunny Goyald478c832016-04-01 12:04:16 -07002283 if (info.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)) {
2284 if (!info.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_ALLOCATED)) {
2285 // This should not happen, as we make sure that an Id is allocated during bind.
2286 return;
2287 }
Sunny Goyal04a324a2017-01-20 21:08:59 -08002288 addFlowHandler.startBindFlow(this, info.appWidgetId, info,
2289 REQUEST_BIND_PENDING_APPWIDGET);
Sunny Goyald478c832016-04-01 12:04:16 -07002290 } else {
Sunny Goyal04a324a2017-01-20 21:08:59 -08002291 addFlowHandler.startConfigActivity(this, info, REQUEST_RECONFIGURE_APPWIDGET);
Sunny Goyalff572272014-07-23 13:58:07 -07002292 }
Sunny Goyale7b8cd92014-08-27 14:04:33 -07002293 } else {
Sunny Goyale7b8cd92014-08-27 14:04:33 -07002294 final String packageName = info.providerName.getPackageName();
Sunny Goyale6e72002017-01-12 16:55:36 -08002295 onClickPendingAppItem(v, packageName, info.installProgress >= 0);
Sunny Goyalff572272014-07-23 13:58:07 -07002296 }
2297 }
2298
2299 /**
Michael Jurka2c3af5f2010-08-03 13:53:20 -07002300 * Event handler for the "grid" button that appears on the home screen, which
2301 * enters all apps mode.
2302 *
2303 * @param v The view that was clicked.
2304 */
Sandeep Siddharthaa9420302014-02-12 18:24:31 -08002305 protected void onClickAllAppsButton(View v) {
2306 if (LOGD) Log.d(TAG, "onClickAllAppsButton");
Winson Chung76648c52015-07-10 14:33:23 -07002307 if (!isAppsViewVisible()) {
Sunny Goyal6c46a6d2016-11-23 02:24:32 +05302308 getUserEventDispatcher().logActionOnControl(Action.Touch.TAP,
2309 ControlType.ALL_APPS_BUTTON);
Hyunyoung Songdd60ce42016-07-27 17:08:38 -07002310 showAppsView(true /* animated */, true /* updatePredictedApps */,
2311 false /* focusSearchBar */);
Winson Chung76648c52015-07-10 14:33:23 -07002312 }
2313 }
2314
2315 protected void onLongClickAllAppsButton(View v) {
2316 if (LOGD) Log.d(TAG, "onLongClickAllAppsButton");
2317 if (!isAppsViewVisible()) {
Sunny Goyal6c46a6d2016-11-23 02:24:32 +05302318 getUserEventDispatcher().logActionOnControl(Action.Touch.LONGPRESS,
2319 ControlType.ALL_APPS_BUTTON);
Hyunyoung Songdd60ce42016-07-27 17:08:38 -07002320 showAppsView(true /* animated */,
Winson Chung76648c52015-07-10 14:33:23 -07002321 true /* updatePredictedApps */, true /* focusSearchBar */);
Sandeep Siddharthaa9420302014-02-12 18:24:31 -08002322 }
2323 }
2324
Sunny Goyale6e72002017-01-12 16:55:36 -08002325 private void onClickPendingAppItem(final View v, final String packageName,
2326 boolean downloadStarted) {
2327 if (downloadStarted) {
2328 // If the download has started, simply direct to the market app.
2329 startMarketIntentForPackage(v, packageName);
2330 return;
2331 }
Sunny Goyale03b8122014-10-08 09:55:24 -07002332 new AlertDialog.Builder(this)
Sunny Goyale7b8cd92014-08-27 14:04:33 -07002333 .setTitle(R.string.abandoned_promises_title)
2334 .setMessage(R.string.abandoned_promise_explanation)
Sunny Goyale6e72002017-01-12 16:55:36 -08002335 .setPositiveButton(R.string.abandoned_search, new DialogInterface.OnClickListener() {
2336 @Override
2337 public void onClick(DialogInterface dialogInterface, int i) {
2338 startMarketIntentForPackage(v, packageName);
2339 }
2340 })
Sunny Goyale7b8cd92014-08-27 14:04:33 -07002341 .setNeutralButton(R.string.abandoned_clean_this,
2342 new DialogInterface.OnClickListener() {
2343 public void onClick(DialogInterface dialog, int id) {
Sunny Goyal7c74e4a2016-12-15 15:53:17 -08002344 final UserHandle user = Process.myUserHandle();
Sunny Goyale7b8cd92014-08-27 14:04:33 -07002345 mWorkspace.removeAbandonedPromise(packageName, user);
2346 }
2347 })
2348 .create().show();
Sunny Goyale6e72002017-01-12 16:55:36 -08002349 }
2350
2351 private void startMarketIntentForPackage(View v, String packageName) {
2352 ItemInfo item = (ItemInfo) v.getTag();
2353 Intent intent = PackageManagerHelper.getMarketIntent(packageName);
2354 boolean success = startActivitySafely(v, intent, item);
2355 if (success && v instanceof BubbleTextView) {
2356 mWaitingForResume = (BubbleTextView) v;
2357 mWaitingForResume.setStayPressed(true);
2358 }
Sunny Goyale7b8cd92014-08-27 14:04:33 -07002359 }
2360
Sandeep Siddharthaa9420302014-02-12 18:24:31 -08002361 /**
2362 * Event handler for an app shortcut click.
2363 *
2364 * @param v The view that was clicked. Must be a tagged with a {@link ShortcutInfo}.
2365 */
Chris Wren40c5ed32014-06-24 18:24:23 -04002366 protected void onClickAppShortcut(final View v) {
Sandeep Siddharthaa9420302014-02-12 18:24:31 -08002367 if (LOGD) Log.d(TAG, "onClickAppShortcut");
2368 Object tag = v.getTag();
2369 if (!(tag instanceof ShortcutInfo)) {
2370 throw new IllegalArgumentException("Input must be a Shortcut");
2371 }
2372
2373 // Open shortcut
2374 final ShortcutInfo shortcut = (ShortcutInfo) tag;
Sunny Goyal1a745e82014-10-02 15:58:31 -07002375
2376 if (shortcut.isDisabled != 0) {
Sunny Goyald3b87ef2016-07-28 12:11:54 -07002377 if ((shortcut.isDisabled &
2378 ~ShortcutInfo.FLAG_DISABLED_SUSPENDED &
2379 ~ShortcutInfo.FLAG_DISABLED_QUIET_USER) == 0) {
2380 // If the app is only disabled because of the above flags, launch activity anyway.
2381 // Framework will tell the user why the app is suspended.
Kenny Guy44cba692016-01-21 19:50:02 +00002382 } else {
Tony Wickham4efffc52016-08-04 16:34:49 -07002383 if (!TextUtils.isEmpty(shortcut.disabledMessage)) {
2384 // Use a message specific to this shortcut, if it has one.
2385 Toast.makeText(this, shortcut.disabledMessage, Toast.LENGTH_SHORT).show();
2386 return;
2387 }
2388 // Otherwise just use a generic error message.
Kenny Guy44cba692016-01-21 19:50:02 +00002389 int error = R.string.activity_not_available;
2390 if ((shortcut.isDisabled & ShortcutInfo.FLAG_DISABLED_SAFEMODE) != 0) {
2391 error = R.string.safemode_shortcut_error;
Sunny Goyald3b87ef2016-07-28 12:11:54 -07002392 } else if ((shortcut.isDisabled & ShortcutInfo.FLAG_DISABLED_BY_PUBLISHER) != 0 ||
2393 (shortcut.isDisabled & ShortcutInfo.FLAG_DISABLED_LOCKED_USER) != 0) {
Sunny Goyal70a7c9b2016-07-28 10:07:32 -07002394 error = R.string.shortcut_not_available;
Kenny Guy44cba692016-01-21 19:50:02 +00002395 }
2396 Toast.makeText(this, error, Toast.LENGTH_SHORT).show();
2397 return;
Sunny Goyal1a745e82014-10-02 15:58:31 -07002398 }
Sunny Goyal1a745e82014-10-02 15:58:31 -07002399 }
2400
Chris Wren40c5ed32014-06-24 18:24:23 -04002401 // Check for abandoned promise
Sunny Goyale6e72002017-01-12 16:55:36 -08002402 if ((v instanceof BubbleTextView) && shortcut.isPromise()) {
2403 String packageName = shortcut.intent.getComponent() != null ?
2404 shortcut.intent.getComponent().getPackageName() : shortcut.intent.getPackage();
2405 if (!TextUtils.isEmpty(packageName)) {
2406 onClickPendingAppItem(v, packageName,
2407 shortcut.hasStatusFlag(ShortcutInfo.FLAG_INSTALL_SESSION_ACTIVE));
2408 return;
2409 }
Chris Wren40c5ed32014-06-24 18:24:23 -04002410 }
2411
Sandeep Siddharthaa9420302014-02-12 18:24:31 -08002412 // Start activities
Sunny Goyal508da152014-08-14 10:53:27 -07002413 startAppShortcutOrInfoActivity(v);
Chris Wren40c5ed32014-06-24 18:24:23 -04002414 }
2415
Sunny Goyala7ce1662016-05-31 15:01:35 -07002416 private void startAppShortcutOrInfoActivity(View v) {
2417 ItemInfo item = (ItemInfo) v.getTag();
Mario Bertschler08ffaae2017-03-20 11:30:27 -07002418 Intent intent;
2419 if (item instanceof PromiseAppInfo) {
2420 PromiseAppInfo promiseAppInfo = (PromiseAppInfo) item;
2421 intent = promiseAppInfo.getMarketIntent();
2422 } else {
2423 intent = item.getIntent();
2424 }
Sunny Goyala7ce1662016-05-31 15:01:35 -07002425 if (intent == null) {
2426 throw new IllegalArgumentException("Input must have a valid intent");
Sunny Goyal508da152014-08-14 10:53:27 -07002427 }
Sunny Goyala7ce1662016-05-31 15:01:35 -07002428 boolean success = startActivitySafely(v, intent, item);
Mario Bertschler0fc6f682017-02-17 12:16:13 -08002429 getUserEventDispatcher().logAppLaunch(v, intent); // TODO for discovered apps b/35802115
Sandeep Siddharthaa9420302014-02-12 18:24:31 -08002430
2431 if (success && v instanceof BubbleTextView) {
2432 mWaitingForResume = (BubbleTextView) v;
2433 mWaitingForResume.setStayPressed(true);
2434 }
2435 }
2436
2437 /**
2438 * Event handler for a folder icon click.
2439 *
2440 * @param v The view that was clicked. Must be an instance of {@link FolderIcon}.
2441 */
2442 protected void onClickFolderIcon(View v) {
2443 if (LOGD) Log.d(TAG, "onClickFolder");
2444 if (!(v instanceof FolderIcon)){
2445 throw new IllegalArgumentException("Input must be a FolderIcon");
2446 }
2447
Sunny Goyal740ac7f2016-09-28 16:47:32 -07002448 Folder folder = ((FolderIcon) v).getFolder();
2449 if (!folder.isOpen() && !folder.isDestroyed()) {
Sandeep Siddharthaa9420302014-02-12 18:24:31 -08002450 // Open the requested folder
Sunny Goyal740ac7f2016-09-28 16:47:32 -07002451 folder.animateOpen();
Sandeep Siddharthaa9420302014-02-12 18:24:31 -08002452 }
Michael Jurka5130e402011-10-13 04:55:35 -07002453 }
2454
Sandeep Siddharthad8058372014-01-28 10:41:15 -08002455 /**
2456 * Event handler for the (Add) Widgets button that appears after a long press
2457 * on the home screen.
2458 */
Sunny Goyald0a6ae72016-06-16 12:29:03 -07002459 public void onClickAddWidgetButton(View view) {
Sandeep Siddharthaa9420302014-02-12 18:24:31 -08002460 if (LOGD) Log.d(TAG, "onClickAddWidgetButton");
Sunny Goyal9b4b0812014-10-08 10:47:28 -07002461 if (mIsSafeModeEnabled) {
2462 Toast.makeText(this, R.string.safemode_widget_error, Toast.LENGTH_SHORT).show();
2463 } else {
Winson Chungb745afb2015-03-02 11:51:23 -08002464 showWidgetsView(true /* animated */, true /* resetPageToZero */);
Adam Cohen9211d422014-10-07 18:14:53 -07002465 }
Sandeep Siddharthad8058372014-01-28 10:41:15 -08002466 }
2467
Sandeep Siddharthaa9420302014-02-12 18:24:31 -08002468 /**
2469 * Event handler for the wallpaper picker button that appears after a long press
2470 * on the home screen.
2471 */
Sunny Goyald0a6ae72016-06-16 12:29:03 -07002472 public void onClickWallpaperPicker(View v) {
Hyunyoung Song0de01172016-10-05 16:27:48 -07002473 if (!Utilities.isWallpaperAllowed(this)) {
Sunny Goyal1ed6c4a2016-04-21 15:16:11 -07002474 Toast.makeText(this, R.string.msg_disabled_by_admin, Toast.LENGTH_SHORT).show();
2475 return;
2476 }
2477
Tony Wickham785f7a52015-08-31 17:28:32 -07002478 int pageScroll = mWorkspace.getScrollForPage(mWorkspace.getPageNearestToCenterOfScreen());
2479 float offset = mWorkspace.mWallpaperOffset.wallpaperOffsetForScroll(pageScroll);
Sunny Goyal2100c782016-08-22 16:00:03 -07002480 setWaitingForResult(new PendingRequestArgs(new ItemInfo()));
Sunny Goyal0eca4e22016-07-20 11:43:06 -07002481 Intent intent = new Intent(Intent.ACTION_SET_WALLPAPER)
Sunny Goyal0eca4e22016-07-20 11:43:06 -07002482 .putExtra(Utilities.EXTRA_WALLPAPER_OFFSET, offset);
Sunny Goyalc677b6b2016-10-17 09:59:01 +01002483
2484 String pickerPackage = getString(R.string.wallpaper_picker_package);
2485 boolean hasTargetPackage = TextUtils.isEmpty(pickerPackage);
2486 if (!hasTargetPackage) {
2487 intent.setPackage(pickerPackage);
2488 }
2489
Sunny Goyal0eca4e22016-07-20 11:43:06 -07002490 intent.setSourceBounds(getViewBounds(v));
Sunny Goyalc677b6b2016-10-17 09:59:01 +01002491 try {
2492 startActivityForResult(intent, REQUEST_PICK_WALLPAPER,
2493 // If there is no target package, use the default intent chooser animation
2494 hasTargetPackage ? getActivityLaunchOptions(v) : null);
2495 } catch (ActivityNotFoundException e) {
2496 setWaitingForResult(null);
2497 Toast.makeText(this, R.string.activity_not_found, Toast.LENGTH_SHORT).show();
2498 }
Sandeep Siddharthaa9420302014-02-12 18:24:31 -08002499 }
2500
2501 /**
2502 * Event handler for a click on the settings button that appears after a long press
2503 * on the home screen.
2504 */
Sunny Goyald0a6ae72016-06-16 12:29:03 -07002505 public void onClickSettingsButton(View v) {
Sandeep Siddharthaa9420302014-02-12 18:24:31 -08002506 if (LOGD) Log.d(TAG, "onClickSettingsButton");
Sunny Goyalf3a09f92016-08-25 09:45:14 -07002507 Intent intent = new Intent(Intent.ACTION_APPLICATION_PREFERENCES)
2508 .setPackage(getPackageName());
2509 intent.setSourceBounds(getViewBounds(v));
Sunny Goyal53f93b92017-05-04 11:23:29 -07002510 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
Sunny Goyalf3a09f92016-08-25 09:45:14 -07002511 startActivity(intent, getActivityLaunchOptions(v));
Sandeep Siddharthaa9420302014-02-12 18:24:31 -08002512 }
2513
Adam Cohen61f560d2013-09-30 15:58:20 -07002514 public View.OnTouchListener getHapticFeedbackTouchListener() {
2515 if (mHapticFeedbackTouchListener == null) {
2516 mHapticFeedbackTouchListener = new View.OnTouchListener() {
Sunny Goyal70660032015-05-14 00:07:08 -07002517 @SuppressLint("ClickableViewAccessibility")
Adam Cohen61f560d2013-09-30 15:58:20 -07002518 @Override
2519 public boolean onTouch(View v, MotionEvent event) {
2520 if ((event.getAction() & MotionEvent.ACTION_MASK) == MotionEvent.ACTION_DOWN) {
2521 v.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY);
2522 }
2523 return false;
2524 }
2525 };
2526 }
2527 return mHapticFeedbackTouchListener;
2528 }
2529
Tony Wickhame2217252016-03-22 16:34:23 -07002530 @Override
2531 public void onAccessibilityStateChanged(boolean enabled) {
2532 mDragLayer.onAccessibilityStateChanged(enabled);
2533 }
2534
Sunny Goyal06e21a22016-08-11 16:02:02 -07002535 public void onDragStarted() {
Adam Cohen9211d422014-10-07 18:14:53 -07002536 if (isOnCustomContent()) {
2537 // Custom content screen doesn't participate in drag and drop. If on custom
2538 // content screen, move to default.
2539 moveWorkspaceToDefaultScreen();
2540 }
Adam Cohen9211d422014-10-07 18:14:53 -07002541 }
Anjali Koppal62d18ed2014-03-10 17:04:03 -07002542
Sandeep Siddharthaab2d9d72013-09-17 13:18:24 -07002543 /**
2544 * Called when the user stops interacting with the launcher.
2545 * This implies that the user is now on the homescreen and is not doing housekeeping.
2546 */
Adam Cohen9211d422014-10-07 18:14:53 -07002547 protected void onInteractionEnd() {
2548 if (mLauncherCallbacks != null) {
2549 mLauncherCallbacks.onInteractionEnd();
2550 }
2551 }
Sandeep Siddharthaab2d9d72013-09-17 13:18:24 -07002552
2553 /**
2554 * Called when the user starts interacting with the launcher.
2555 * The possible interactions are:
2556 * - open all apps
2557 * - reorder an app shortcut, or a widget
2558 * - open the overview mode.
2559 * This is a good time to stop doing things that only make sense
2560 * when the user is on the homescreen and not doing housekeeping.
2561 */
Adam Cohen9211d422014-10-07 18:14:53 -07002562 protected void onInteractionBegin() {
2563 if (mLauncherCallbacks != null) {
2564 mLauncherCallbacks.onInteractionBegin();
2565 }
2566 }
Sandeep Siddharthaab2d9d72013-09-17 13:18:24 -07002567
Winson Chungcd99cd32015-04-29 11:03:24 -07002568 /** Updates the interaction state. */
2569 public void updateInteraction(Workspace.State fromState, Workspace.State toState) {
Winson Chung83f59ab2015-05-05 17:21:58 -07002570 // Only update the interacting state if we are transitioning to/from a view with an
Winson Chungcd99cd32015-04-29 11:03:24 -07002571 // overlay
Winson Chungef7f8742015-06-04 17:18:17 -07002572 boolean fromStateWithOverlay = fromState != Workspace.State.NORMAL;
2573 boolean toStateWithOverlay = toState != Workspace.State.NORMAL;
Winson Chung83f59ab2015-05-05 17:21:58 -07002574 if (toStateWithOverlay) {
Winson Chungcd99cd32015-04-29 11:03:24 -07002575 onInteractionBegin();
Winson Chung83f59ab2015-05-05 17:21:58 -07002576 } else if (fromStateWithOverlay) {
Winson Chungcd99cd32015-04-29 11:03:24 -07002577 onInteractionEnd();
2578 }
2579 }
2580
Sunny Goyala7ce1662016-05-31 15:01:35 -07002581 private void startShortcutIntentSafely(Intent intent, Bundle optsBundle, ItemInfo info) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002582 try {
Sunny Goyala7ce1662016-05-31 15:01:35 -07002583 StrictMode.VmPolicy oldPolicy = StrictMode.getVmPolicy();
2584 try {
2585 // Temporarily disable deathPenalty on all default checks. For eg, shortcuts
2586 // containing file Uri's would cause a crash as penaltyDeathOnFileUriExposure
2587 // is enabled by default on NYC.
2588 StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder().detectAll()
2589 .penaltyLog().build());
Tony Wickhambfbf7f92016-05-19 11:19:39 -07002590
2591 if (info.itemType == LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT) {
2592 String id = ((ShortcutInfo) info).getDeepShortcutId();
2593 String packageName = intent.getPackage();
Sunny Goyaldde4fd92016-11-21 16:02:39 +05302594 DeepShortcutManager.getInstance(this).startShortcut(
Sunny Goyal9994b2b2016-06-23 14:17:24 -07002595 packageName, id, intent.getSourceBounds(), optsBundle, info.user);
Tony Wickhambfbf7f92016-05-19 11:19:39 -07002596 } else {
2597 // Could be launching some bookkeeping activity
2598 startActivity(intent, optsBundle);
2599 }
Sunny Goyala7ce1662016-05-31 15:01:35 -07002600 } finally {
2601 StrictMode.setVmPolicy(oldPolicy);
Kenny Guy1317e2d2014-05-08 18:52:50 +01002602 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002603 } catch (SecurityException e) {
Sunny Goyala7ce1662016-05-31 15:01:35 -07002604 // Due to legacy reasons, direct call shortcuts require Launchers to have the
2605 // corresponding permission. Show the appropriate permission prompt if that
2606 // is the case.
2607 if (intent.getComponent() == null
2608 && Intent.ACTION_CALL.equals(intent.getAction())
2609 && checkSelfPermission(Manifest.permission.CALL_PHONE) !=
2610 PackageManager.PERMISSION_GRANTED) {
Sunny Goyal2100c782016-08-22 16:00:03 -07002611
2612 setWaitingForResult(PendingRequestArgs
2613 .forIntent(REQUEST_PERMISSION_CALL_PHONE, intent, info));
Sunny Goyala7ce1662016-05-31 15:01:35 -07002614 requestPermissions(new String[]{Manifest.permission.CALL_PHONE},
2615 REQUEST_PERMISSION_CALL_PHONE);
2616 } else {
2617 // No idea why this was thrown.
2618 throw e;
Sunny Goyal28c6b962015-10-12 11:42:05 -07002619 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002620 }
2621 }
Winson Chungaafa03c2010-06-11 17:34:16 -07002622
Sunny Goyalfe770c92016-09-27 14:38:58 -07002623 @TargetApi(Build.VERSION_CODES.M)
Tonye3c59252017-05-02 21:32:27 -07002624 public Bundle getActivityLaunchOptions(View v) {
Sunny Goyala7ce1662016-05-31 15:01:35 -07002625 if (Utilities.ATLEAST_MARSHMALLOW) {
2626 int left = 0, top = 0;
2627 int width = v.getMeasuredWidth(), height = v.getMeasuredHeight();
2628 if (v instanceof TextView) {
2629 // Launch from center of icon, not entire view
2630 Drawable icon = Workspace.getTextViewIcon((TextView) v);
2631 if (icon != null) {
2632 Rect bounds = icon.getBounds();
2633 left = (width - bounds.width()) / 2;
2634 top = v.getPaddingTop();
2635 width = bounds.width();
2636 height = bounds.height();
2637 }
2638 }
2639 return ActivityOptions.makeClipRevealAnimation(v, left, top, width, height).toBundle();
2640 } else if (Utilities.ATLEAST_LOLLIPOP_MR1) {
2641 // On L devices, we use the device default slide-up transition.
2642 // On L MR1 devices, we use a custom version of the slide-up transition which
2643 // doesn't have the delay present in the device default.
2644 return ActivityOptions.makeCustomAnimation(
2645 this, R.anim.task_open_enter, R.anim.no_anim).toBundle();
2646 }
2647 return null;
2648 }
2649
Tonye3c59252017-05-02 21:32:27 -07002650 public Rect getViewBounds(View v) {
Sunny Goyal0eca4e22016-07-20 11:43:06 -07002651 int[] pos = new int[2];
2652 v.getLocationOnScreen(pos);
2653 return new Rect(pos[0], pos[1], pos[0] + v.getWidth(), pos[1] + v.getHeight());
2654 }
2655
Sunny Goyala7ce1662016-05-31 15:01:35 -07002656 public boolean startActivitySafely(View v, Intent intent, ItemInfo item) {
Sunny Goyalc5c60ad2014-07-14 12:02:01 -07002657 if (mIsSafeModeEnabled && !Utilities.isSystemApp(this, intent)) {
2658 Toast.makeText(this, R.string.safemode_shortcut_error, Toast.LENGTH_SHORT).show();
2659 return false;
2660 }
Sunny Goyala7ce1662016-05-31 15:01:35 -07002661 // Only launch using the new animation if the shortcut has not opted out (this is a
2662 // private contract between launcher and may be ignored in the future).
2663 boolean useLaunchAnimation = (v != null) &&
2664 !intent.hasExtra(INTENT_EXTRA_IGNORE_LAUNCH_ANIMATION);
2665 Bundle optsBundle = useLaunchAnimation ? getActivityLaunchOptions(v) : null;
2666
Sunny Goyal24bb66a2017-03-21 15:12:01 -07002667 UserHandle user = item == null ? null : item.user;
Sunny Goyala7ce1662016-05-31 15:01:35 -07002668
2669 // Prepare intent
2670 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
2671 if (v != null) {
Sunny Goyal0eca4e22016-07-20 11:43:06 -07002672 intent.setSourceBounds(getViewBounds(v));
Sunny Goyala7ce1662016-05-31 15:01:35 -07002673 }
2674 try {
Mario Bertschler0fc6f682017-02-17 12:16:13 -08002675 if (Utilities.ATLEAST_MARSHMALLOW
2676 && (item instanceof ShortcutInfo)
Tony Wickhambfbf7f92016-05-19 11:19:39 -07002677 && (item.itemType == Favorites.ITEM_TYPE_SHORTCUT
Mario Bertschler0fc6f682017-02-17 12:16:13 -08002678 || item.itemType == Favorites.ITEM_TYPE_DEEP_SHORTCUT)
Sunny Goyale6e72002017-01-12 16:55:36 -08002679 && !((ShortcutInfo) item).isPromise()) {
Sunny Goyala7ce1662016-05-31 15:01:35 -07002680 // Shortcuts need some special checks due to legacy reasons.
2681 startShortcutIntentSafely(intent, optsBundle, item);
Sunny Goyal7c74e4a2016-12-15 15:53:17 -08002682 } else if (user == null || user.equals(Process.myUserHandle())) {
Sunny Goyala7ce1662016-05-31 15:01:35 -07002683 // Could be launching some bookkeeping activity
2684 startActivity(intent, optsBundle);
2685 } else {
2686 LauncherAppsCompat.getInstance(this).startActivityForProfile(
2687 intent.getComponent(), user, intent.getSourceBounds(), optsBundle);
2688 }
2689 return true;
2690 } catch (ActivityNotFoundException|SecurityException e) {
2691 Toast.makeText(this, R.string.activity_not_found, Toast.LENGTH_SHORT).show();
2692 Log.e(TAG, "Unable to launch. tag=" + item + " intent=" + intent, e);
2693 }
2694 return false;
Michael Jurka86a720e2012-05-09 11:23:23 -07002695 }
2696
Tony Wickhamdadb3042016-02-24 11:07:00 -08002697 @Override
Jon Miranda379198e2016-09-23 08:54:40 -07002698 public boolean dispatchTouchEvent(MotionEvent ev) {
2699 mLastDispatchTouchEventX = ev.getX();
2700 return super.dispatchTouchEvent(ev);
2701 }
2702
2703 @Override
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002704 public boolean onLongClick(View v) {
Winson Chung36a62fe2012-05-06 18:04:42 -07002705 if (!isDraggingEnabled()) return false;
2706 if (isWorkspaceLocked()) return false;
2707 if (mState != State.WORKSPACE) return false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002708
Hyunyoung Song68f98ac2016-07-22 14:22:49 -07002709 if ((FeatureFlags.LAUNCHER3_ALL_APPS_PULL_UP && v instanceof PageIndicator) ||
2710 (v == mAllAppsButton && mAllAppsButton != null)) {
Winson Chung76648c52015-07-10 14:33:23 -07002711 onLongClickAllAppsButton(v);
2712 return true;
2713 }
2714
Jon Mirandacc42c5b2016-10-27 17:15:27 -07002715
Jon Miranda51f037d2016-11-07 08:37:20 -08002716 boolean ignoreLongPressToOverview =
2717 mDeviceProfile.shouldIgnoreLongPressToOverview(mLastDispatchTouchEventX);
Jon Miranda379198e2016-09-23 08:54:40 -07002718
Adam Cohen1697b792013-09-17 19:08:21 -07002719 if (v instanceof Workspace) {
2720 if (!mWorkspace.isInOverviewMode()) {
Jon Mirandacc42c5b2016-10-27 17:15:27 -07002721 if (!mWorkspace.isTouchActive() && !ignoreLongPressToOverview) {
Sunny Goyal6c46a6d2016-11-23 02:24:32 +05302722 getUserEventDispatcher().logActionOnContainer(Action.Touch.LONGPRESS,
2723 Action.Direction.NONE, ContainerType.WORKSPACE,
Jon Mirandaf3e35d92016-10-05 14:08:11 -07002724 mWorkspace.getCurrentPage());
Winson Chungdc61c4d2015-04-20 18:26:57 -07002725 showOverviewMode(true);
Adam Cohen93c97562013-09-26 13:48:01 -07002726 mWorkspace.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS,
2727 HapticFeedbackConstants.FLAG_IGNORE_VIEW_SETTING);
2728 return true;
2729 } else {
2730 return false;
2731 }
Adam Cohenaa4c8c12014-06-06 11:52:52 -07002732 } else {
2733 return false;
Adam Cohen1697b792013-09-17 19:08:21 -07002734 }
Adam Cohen1697b792013-09-17 19:08:21 -07002735 }
2736
Adam Cohene0aaa0d2014-05-12 12:44:22 -07002737 CellLayout.CellInfo longClickCellInfo = null;
2738 View itemUnderLongClick = null;
2739 if (v.getTag() instanceof ItemInfo) {
2740 ItemInfo info = (ItemInfo) v.getTag();
Adam Cohenc9735cf2015-01-23 16:11:55 -08002741 longClickCellInfo = new CellLayout.CellInfo(v, info);
Adam Cohene0aaa0d2014-05-12 12:44:22 -07002742 itemUnderLongClick = longClickCellInfo.cell;
Sunny Goyal2100c782016-08-22 16:00:03 -07002743 mPendingRequestArgs = null;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002744 }
2745
Winson Chung3d503fb2011-07-13 17:25:49 -07002746 // The hotseat touch handling does not go through Workspace, and we always allow long press
2747 // on hotseat items.
Sunny Goyal8e2133b2015-05-06 13:39:07 -07002748 if (!mDragController.isDragging()) {
Michael Jurka0280c3b2010-09-17 15:00:07 -07002749 if (itemUnderLongClick == null) {
Adam Cohend3ecce92013-09-16 14:58:00 -07002750 // User long pressed on empty space
Adam Cohend3ecce92013-09-16 14:58:00 -07002751 if (mWorkspace.isInOverviewMode()) {
2752 mWorkspace.startReordering(v);
Sunny Goyal6c46a6d2016-11-23 02:24:32 +05302753 getUserEventDispatcher().logActionOnContainer(Action.Touch.LONGPRESS,
2754 Action.Direction.NONE, ContainerType.OVERVIEW);
Adam Cohend3ecce92013-09-16 14:58:00 -07002755 } else {
Jon Mirandacc42c5b2016-10-27 17:15:27 -07002756 if (ignoreLongPressToOverview) {
Jon Miranda379198e2016-09-23 08:54:40 -07002757 return false;
2758 }
Sunny Goyal6c46a6d2016-11-23 02:24:32 +05302759 getUserEventDispatcher().logActionOnContainer(Action.Touch.LONGPRESS,
2760 Action.Direction.NONE, ContainerType.WORKSPACE,
Jon Mirandaf3e35d92016-10-05 14:08:11 -07002761 mWorkspace.getCurrentPage());
Winson Chungdc61c4d2015-04-20 18:26:57 -07002762 showOverviewMode(true);
Adam Cohendedbd962013-07-11 14:21:49 -07002763 }
Jon Miranda379198e2016-09-23 08:54:40 -07002764 mWorkspace.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS,
2765 HapticFeedbackConstants.FLAG_IGNORE_VIEW_SETTING);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002766 } else {
Sunny Goyalbb011da2016-06-15 15:42:29 -07002767 final boolean isAllAppsButton =
2768 !FeatureFlags.NO_ALL_APPS_ICON && isHotseatLayout(v) &&
2769 mDeviceProfile.inv.isAllAppsButtonRank(mHotseat.getOrderInHotseat(
2770 longClickCellInfo.cellX, longClickCellInfo.cellY));
Dan Sandlere26d0942014-01-13 14:30:14 -05002771 if (!(itemUnderLongClick instanceof Folder || isAllAppsButton)) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002772 // User long pressed on an item
Tony Wickham10236d62016-09-28 12:49:25 -07002773 mWorkspace.startDrag(longClickCellInfo, new DragOptions());
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002774 }
2775 }
2776 }
2777 return true;
2778 }
2779
Winson Chung3d503fb2011-07-13 17:25:49 -07002780 boolean isHotseatLayout(View layout) {
Sunny Goyalc13403c2016-11-18 23:44:48 -08002781 // TODO: Remove this method
Winson Chung3d503fb2011-07-13 17:25:49 -07002782 return mHotseat != null && layout != null &&
2783 (layout instanceof CellLayout) && (layout == mHotseat.getLayout());
2784 }
Romain Guy1fbc1c82009-11-09 20:43:08 -08002785
Winson Chung3d503fb2011-07-13 17:25:49 -07002786 /**
2787 * Returns the CellLayout of the specified container at the specified screen.
2788 */
Sunny Goyal92820592015-03-02 11:31:35 -08002789 public CellLayout getCellLayout(long container, long screenId) {
Winson Chung3d503fb2011-07-13 17:25:49 -07002790 if (container == LauncherSettings.Favorites.CONTAINER_HOTSEAT) {
2791 if (mHotseat != null) {
2792 return mHotseat.getLayout();
2793 } else {
2794 return null;
Romain Guye6b8e2f2009-11-10 11:56:55 -08002795 }
Winson Chung3d503fb2011-07-13 17:25:49 -07002796 } else {
Winson Chungb745afb2015-03-02 11:51:23 -08002797 return mWorkspace.getScreenWithId(screenId);
Romain Guya6abce82009-11-10 02:54:41 -08002798 }
2799 }
2800
Winson Chungb745afb2015-03-02 11:51:23 -08002801 /**
2802 * For overridden classes.
2803 */
Daniel Sandler843e8602010-06-07 14:59:01 -04002804 public boolean isAllAppsVisible() {
Winson Chungb745afb2015-03-02 11:51:23 -08002805 return isAppsViewVisible();
2806 }
2807
2808 public boolean isAppsViewVisible() {
2809 return (mState == State.APPS) || (mOnResumeState == State.APPS);
2810 }
2811
2812 public boolean isWidgetsViewVisible() {
2813 return (mState == State.WIDGETS) || (mOnResumeState == State.WIDGETS);
Joe Onoratofb0ca672009-09-14 17:55:46 -04002814 }
2815
Michael Jurkae326f182011-11-21 14:05:46 -08002816 @Override
2817 public void onTrimMemory(int level) {
2818 super.onTrimMemory(level);
Adam Cohen3f9c9712014-10-31 11:48:25 -07002819 if (level >= ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN) {
2820 // The widget preview db can result in holding onto over
2821 // 3MB of memory for caching which isn't necessary.
2822 SQLiteDatabase.releaseMemory();
2823
Adam Cohenc8f4e1b2014-11-19 16:03:20 -08002824 // This clears all widget bitmaps from the widget tray
Hyunyoung Song3f471442015-04-08 19:01:34 -07002825 // TODO(hyunyoungs)
Michael Jurkae326f182011-11-21 14:05:46 -08002826 }
Robert Kozikowski67c30862015-03-30 23:46:46 +01002827 if (mLauncherCallbacks != null) {
2828 mLauncherCallbacks.onTrimMemory(level);
2829 }
Michael Jurkae326f182011-11-21 14:05:46 -08002830 }
2831
Winson5c6bdbb2015-09-03 11:36:19 -07002832 public boolean showWorkspace(boolean animated) {
Winson10612a72015-09-09 17:06:09 -07002833 return showWorkspace(animated, null);
Adam Cohened307df2013-10-02 09:37:31 -07002834 }
2835
Winson5c6bdbb2015-09-03 11:36:19 -07002836 public boolean showWorkspace(boolean animated, Runnable onCompleteRunnable) {
Winson Chung0f785722015-04-08 10:27:49 -07002837 boolean changed = mState != State.WORKSPACE ||
2838 mWorkspace.getState() != Workspace.State.NORMAL;
Hyunyoung Song9dcf0a32016-07-27 10:55:51 -07002839 if (changed || mAllAppsController.isTransitioning()) {
Michael Jurkab3e22d92011-10-31 15:58:33 -07002840 mWorkspace.setVisibility(View.VISIBLE);
Winson Chung006ee262015-08-03 14:40:11 -07002841 mStateTransitionAnimation.startAnimationToWorkspace(mState, mWorkspace.getState(),
Winson2a87fe82015-08-07 10:37:21 -07002842 Workspace.State.NORMAL, animated, onCompleteRunnable);
Winson Chungc7d2b602012-05-16 17:02:20 -07002843
Michael Jurkab3e22d92011-10-31 15:58:33 -07002844 // Set focus to the AppsCustomize button
2845 if (mAllAppsButton != null) {
2846 mAllAppsButton.requestFocus();
2847 }
Michael Jurkac0e8fca2010-10-06 16:41:29 -07002848 }
Adam Lesinski6b879f02010-11-04 16:15:23 -07002849
Michael Jurkac0e8fca2010-10-06 16:41:29 -07002850 // Change the state *after* we've called all the transition code
Mario Bertschleracbf5702017-03-03 10:58:06 -08002851 setState(State.WORKSPACE);
Svetoslav Ganov815ba2d2011-01-07 14:55:17 -08002852
Winson Chung0f785722015-04-08 10:27:49 -07002853 if (changed) {
2854 // Send an accessibility event to announce the context change
2855 getWindow().getDecorView()
2856 .sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
Winson Chung0f785722015-04-08 10:27:49 -07002857 }
Winson5c6bdbb2015-09-03 11:36:19 -07002858 return changed;
Bjorn Bringertc459e522013-06-07 19:36:01 +01002859 }
2860
Winsone9f27272015-10-13 10:47:51 -07002861 /**
2862 * Shows the overview button.
2863 */
Sunny Goyald0a6ae72016-06-16 12:29:03 -07002864 public void showOverviewMode(boolean animated) {
Winsone9f27272015-10-13 10:47:51 -07002865 showOverviewMode(animated, false);
2866 }
2867
2868 /**
2869 * Shows the overview button, and if {@param requestButtonFocus} is set, will force the focus
2870 * onto one of the overview panel buttons.
2871 */
2872 void showOverviewMode(boolean animated, boolean requestButtonFocus) {
2873 Runnable postAnimRunnable = null;
2874 if (requestButtonFocus) {
2875 postAnimRunnable = new Runnable() {
2876 @Override
2877 public void run() {
2878 // Hitting the menu button when in touch mode does not trigger touch mode to
2879 // be disabled, so if requested, force focus on one of the overview panel
2880 // buttons.
2881 mOverviewPanel.requestFocusFromTouch();
2882 }
2883 };
2884 }
Adam Cohened307df2013-10-02 09:37:31 -07002885 mWorkspace.setVisibility(View.VISIBLE);
Winson Chung006ee262015-08-03 14:40:11 -07002886 mStateTransitionAnimation.startAnimationToWorkspace(mState, mWorkspace.getState(),
Winson6e6a9b42015-10-13 17:52:17 -07002887 Workspace.State.OVERVIEW, animated, postAnimRunnable);
Mario Bertschleracbf5702017-03-03 10:58:06 -08002888 setState(State.WORKSPACE);
2889
Hyunyoung Song0a9c0922016-09-20 22:50:06 -07002890 // If animated from long press, then don't allow any of the controller in the drag
2891 // layer to intercept any remaining touch.
2892 mWorkspace.requestDisallowInterceptTouchEvent(animated);
Joe Onorato00acb122009-08-04 16:04:30 -04002893 }
2894
Mario Bertschleracbf5702017-03-03 10:58:06 -08002895 private void setState(State state) {
2896 this.mState = state;
2897 updateSoftInputMode();
2898 }
2899
2900 private void updateSoftInputMode() {
2901 if (FeatureFlags.LAUNCHER3_UPDATE_SOFT_INPUT_MODE) {
2902 final int mode;
2903 if (isAppsViewVisible()) {
2904 mode = SOFT_INPUT_MODE_ALL_APPS;
2905 } else {
2906 mode = SOFT_INPUT_MODE_DEFAULT;
2907 }
2908 getWindow().setSoftInputMode(mode);
2909 }
2910 }
2911
Winson Chungb745afb2015-03-02 11:51:23 -08002912 /**
2913 * Shows the apps view.
2914 */
Hyunyoung Songdd60ce42016-07-27 17:08:38 -07002915 public void showAppsView(boolean animated, boolean updatePredictedApps,
Winson Chung76648c52015-07-10 14:33:23 -07002916 boolean focusSearchBar) {
Hyunyoung Songc001cf52016-07-21 17:32:43 -07002917 markAppsViewShown();
Winson Chung4ac30062015-05-08 17:34:17 -07002918 if (updatePredictedApps) {
2919 tryAndUpdatePredictedApps();
2920 }
Winson Chung76648c52015-07-10 14:33:23 -07002921 showAppsOrWidgets(State.APPS, animated, focusSearchBar);
Winson Chungb745afb2015-03-02 11:51:23 -08002922 }
Michael Jurkab3e22d92011-10-31 15:58:33 -07002923
Winson Chungb745afb2015-03-02 11:51:23 -08002924 /**
2925 * Shows the widgets view.
2926 */
2927 void showWidgetsView(boolean animated, boolean resetPageToZero) {
Sunny Goyal2bba4c32015-05-18 15:42:48 -07002928 if (LOGD) Log.d(TAG, "showWidgetsView:" + animated + " resetPageToZero:" + resetPageToZero);
Winson Chung82963d52013-10-09 11:20:57 -07002929 if (resetPageToZero) {
Hyunyoung Song3f471442015-04-08 19:01:34 -07002930 mWidgetsView.scrollToTop();
Winson Chung82963d52013-10-09 11:20:57 -07002931 }
Winson Chung76648c52015-07-10 14:33:23 -07002932 showAppsOrWidgets(State.WIDGETS, animated, false);
Hyunyoung Song3f471442015-04-08 19:01:34 -07002933
2934 mWidgetsView.post(new Runnable() {
Adam Cohendcc5e712014-06-23 15:38:55 -04002935 @Override
2936 public void run() {
Hyunyoung Song3f471442015-04-08 19:01:34 -07002937 mWidgetsView.requestFocus();
Adam Cohendcc5e712014-06-23 15:38:55 -04002938 }
2939 });
Winson Chungb745afb2015-03-02 11:51:23 -08002940 }
2941
2942 /**
2943 * Sets up the transition to show the apps/widgets view.
Hyunyoung Songb7900832015-05-15 16:29:45 -07002944 *
2945 * @return whether the current from and to state allowed this operation
Winson Chungb745afb2015-03-02 11:51:23 -08002946 */
Hyunyoung Songb7900832015-05-15 16:29:45 -07002947 // TODO: calling method should use the return value so that when {@code false} is returned
2948 // the workspace transition doesn't fall into invalid state.
Winson Chung76648c52015-07-10 14:33:23 -07002949 private boolean showAppsOrWidgets(State toState, boolean animated, boolean focusSearchBar) {
Hyunyoung Song9dcf0a32016-07-27 10:55:51 -07002950 if (!(mState == State.WORKSPACE ||
2951 mState == State.APPS_SPRING_LOADED ||
2952 mState == State.WIDGETS_SPRING_LOADED ||
2953 (mState == State.APPS && mAllAppsController.isTransitioning()))) {
Hyunyoung Songb7900832015-05-15 16:29:45 -07002954 return false;
2955 }
2956 if (toState != State.APPS && toState != State.WIDGETS) {
2957 return false;
2958 }
Winson Chungb745afb2015-03-02 11:51:23 -08002959
Hyunyoung Song06ca7562016-07-29 13:03:54 -07002960 // This is a safe and supported transition to bypass spring_loaded mode.
2961 if (mExitSpringLoadedModeRunnable != null) {
2962 mHandler.removeCallbacks(mExitSpringLoadedModeRunnable);
2963 mExitSpringLoadedModeRunnable = null;
2964 }
2965
Winson Chungb745afb2015-03-02 11:51:23 -08002966 if (toState == State.APPS) {
Sunny Goyaldb364372016-10-26 19:12:47 -07002967 mStateTransitionAnimation.startAnimationToAllApps(animated, focusSearchBar);
Winson Chungb745afb2015-03-02 11:51:23 -08002968 } else {
Sunny Goyaldb364372016-10-26 19:12:47 -07002969 mStateTransitionAnimation.startAnimationToWidgets(animated);
Winson Chungb745afb2015-03-02 11:51:23 -08002970 }
Michael Jurkab3e22d92011-10-31 15:58:33 -07002971
Michael Jurkab3e22d92011-10-31 15:58:33 -07002972 // Change the state *after* we've called all the transition code
Mario Bertschleracbf5702017-03-03 10:58:06 -08002973 setState(toState);
Sunny Goyal740ac7f2016-09-28 16:47:32 -07002974 AbstractFloatingView.closeAllOpenViews(this);
Michael Jurkab3e22d92011-10-31 15:58:33 -07002975
2976 // Send an accessibility event to announce the context change
alanv1d4fde62012-10-17 13:15:47 -07002977 getWindow().getDecorView()
2978 .sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
Hyunyoung Songb7900832015-05-15 16:29:45 -07002979 return true;
Michael Jurkab3e22d92011-10-31 15:58:33 -07002980 }
2981
Winson Chungcd99cd32015-04-29 11:03:24 -07002982 /**
2983 * Updates the workspace and interaction state on state change, and return the animation to this
2984 * new state.
2985 */
Sunny Goyalce5a7e52015-07-08 15:44:27 -07002986 public Animator startWorkspaceStateChangeAnimation(Workspace.State toState,
Sunny Goyalb5e65c82016-10-26 18:32:38 -07002987 boolean animated, AnimationLayerSet layerViews) {
Winson Chungcd99cd32015-04-29 11:03:24 -07002988 Workspace.State fromState = mWorkspace.getState();
Winson2a87fe82015-08-07 10:37:21 -07002989 Animator anim = mWorkspace.setStateWithAnimation(toState, animated, layerViews);
Winson Chungcd99cd32015-04-29 11:03:24 -07002990 updateInteraction(fromState, toState);
2991 return anim;
2992 }
2993
Hyunyoung Song3f471442015-04-08 19:01:34 -07002994 public void enterSpringLoadedDragMode() {
Sunny Goyal2bba4c32015-05-18 15:42:48 -07002995 if (LOGD) Log.d(TAG, String.format("enterSpringLoadedDragMode [mState=%s", mState.name()));
Tony Wickham94e0d372015-09-11 12:17:48 -07002996 if (isStateSpringLoaded()) {
Winson Chungb745afb2015-03-02 11:51:23 -08002997 return;
Winson Chungb26f3d62011-06-02 10:49:29 -07002998 }
Winson Chungb745afb2015-03-02 11:51:23 -08002999
Winson Chung006ee262015-08-03 14:40:11 -07003000 mStateTransitionAnimation.startAnimationToWorkspace(mState, mWorkspace.getState(),
Winson2a87fe82015-08-07 10:37:21 -07003001 Workspace.State.SPRING_LOADED, true /* animated */,
Winson Chungdc61c4d2015-04-20 18:26:57 -07003002 null /* onCompleteRunnable */);
Mario Bertschleracbf5702017-03-03 10:58:06 -08003003 setState(State.WORKSPACE_SPRING_LOADED);
Michael Jurkad3ef3062010-11-23 16:23:58 -08003004 }
Adam Cohen7777d962011-08-18 18:58:38 -07003005
Hyunyoung Song3f471442015-04-08 19:01:34 -07003006 public void exitSpringLoadedDragModeDelayed(final boolean successfulDrop, int delay,
Adam Cohened66b2b2012-01-23 17:28:51 -08003007 final Runnable onCompleteRunnable) {
Tony Wickham94e0d372015-09-11 12:17:48 -07003008 if (!isStateSpringLoaded()) return;
Winson Chung09bfc452011-09-09 11:30:20 -07003009
Hyunyoung Song06ca7562016-07-29 13:03:54 -07003010 if (mExitSpringLoadedModeRunnable != null) {
3011 mHandler.removeCallbacks(mExitSpringLoadedModeRunnable);
3012 }
3013 mExitSpringLoadedModeRunnable = new Runnable() {
Winson Chung557d6ed2011-07-08 15:34:52 -07003014 @Override
3015 public void run() {
Winson Chung6a3fd3f2011-08-02 14:03:26 -07003016 if (successfulDrop) {
Hyunyoung Song3f471442015-04-08 19:01:34 -07003017 // TODO(hyunyoungs): verify if this hack is still needed, if not, delete.
3018 //
Michael Jurka7bdb25a2011-08-03 15:16:44 -07003019 // Before we show workspace, hide all apps again because
3020 // exitSpringLoadedDragMode made it visible. This is a bit hacky; we should
3021 // clean up our state transition functions
Hyunyoung Song3f471442015-04-08 19:01:34 -07003022 mWidgetsView.setVisibility(View.GONE);
Adam Cohened66b2b2012-01-23 17:28:51 -08003023 showWorkspace(true, onCompleteRunnable);
Adam Cohen7777d962011-08-18 18:58:38 -07003024 } else {
3025 exitSpringLoadedDragMode();
Winson Chung6a3fd3f2011-08-02 14:03:26 -07003026 }
Hyunyoung Song06ca7562016-07-29 13:03:54 -07003027 mExitSpringLoadedModeRunnable = null;
Winson Chung557d6ed2011-07-08 15:34:52 -07003028 }
Hyunyoung Song06ca7562016-07-29 13:03:54 -07003029 };
3030 mHandler.postDelayed(mExitSpringLoadedModeRunnable, delay);
Winson Chung557d6ed2011-07-08 15:34:52 -07003031 }
Michael Jurkab3e22d92011-10-31 15:58:33 -07003032
Tony Wickhame0c33232016-02-08 11:37:04 -08003033 boolean isStateSpringLoaded() {
Tony Wickham94e0d372015-09-11 12:17:48 -07003034 return mState == State.WORKSPACE_SPRING_LOADED || mState == State.APPS_SPRING_LOADED
3035 || mState == State.WIDGETS_SPRING_LOADED;
3036 }
3037
Sunny Goyal0f76b562016-12-13 19:37:10 -08003038 public void exitSpringLoadedDragMode() {
Winson Chungb745afb2015-03-02 11:51:23 -08003039 if (mState == State.APPS_SPRING_LOADED) {
Hyunyoung Songdd60ce42016-07-27 17:08:38 -07003040 showAppsView(true /* animated */,
Winson Chung76648c52015-07-10 14:33:23 -07003041 false /* updatePredictedApps */, false /* focusSearchBar */);
Winson Chungb745afb2015-03-02 11:51:23 -08003042 } else if (mState == State.WIDGETS_SPRING_LOADED) {
Winson Chungcd99cd32015-04-29 11:03:24 -07003043 showWidgetsView(true, false);
Tony Wickham94e0d372015-09-11 12:17:48 -07003044 } else if (mState == State.WORKSPACE_SPRING_LOADED) {
3045 showWorkspace(true);
Winson Chungf0ea4d32011-06-06 14:27:16 -07003046 }
Winson Chungf0ea4d32011-06-06 14:27:16 -07003047 }
3048
Winson Chung4ac30062015-05-08 17:34:17 -07003049 /**
3050 * Updates the set of predicted apps if it hasn't been updated since the last time Launcher was
3051 * resumed.
3052 */
Hyunyoung Songa9a8a422016-06-15 16:45:48 -07003053 public void tryAndUpdatePredictedApps() {
Winson Chung4ac30062015-05-08 17:34:17 -07003054 if (mLauncherCallbacks != null) {
Winson Chung6b1c73f2015-06-18 11:38:42 -07003055 List<ComponentKey> apps = mLauncherCallbacks.getPredictedApps();
Winson Chung91c05952015-06-25 12:17:30 -07003056 if (apps != null) {
Winson Chung4ac30062015-05-08 17:34:17 -07003057 mAppsView.setPredictedApps(apps);
Hyunyoung Songaa953652016-04-19 18:30:24 -07003058 getUserEventDispatcher().setPredictedApps(apps);
Winson Chung4ac30062015-05-08 17:34:17 -07003059 }
3060 }
3061 }
3062
Michael Jurkab3e22d92011-10-31 15:58:33 -07003063 void lockAllApps() {
3064 // TODO
3065 }
3066
3067 void unlockAllApps() {
3068 // TODO
3069 }
3070
Michael Jurkad7c28052012-04-27 15:43:36 -07003071 @Override
3072 public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
alanv1d4fde62012-10-17 13:15:47 -07003073 final boolean result = super.dispatchPopulateAccessibilityEvent(event);
Michael Jurkad7c28052012-04-27 15:43:36 -07003074 final List<CharSequence> text = event.getText();
3075 text.clear();
alanv1d4fde62012-10-17 13:15:47 -07003076 // Populate event with a fake title based on the current state.
Winson Chungb745afb2015-03-02 11:51:23 -08003077 if (mState == State.APPS) {
Sunny Goyalc525d802015-04-29 11:05:34 -07003078 text.add(getString(R.string.all_apps_button_label));
Winson Chungb745afb2015-03-02 11:51:23 -08003079 } else if (mState == State.WIDGETS) {
Sunny Goyalc525d802015-04-29 11:05:34 -07003080 text.add(getString(R.string.widget_button_text));
Hyunyoung Song166e6482015-06-25 21:06:07 -07003081 } else if (mWorkspace != null) {
3082 text.add(mWorkspace.getCurrentPageDescription());
alanv1d4fde62012-10-17 13:15:47 -07003083 } else {
3084 text.add(getString(R.string.all_apps_home_button_label));
3085 }
Michael Jurkad7c28052012-04-27 15:43:36 -07003086 return result;
3087 }
3088
Patrick Dubroyceae05d2010-08-30 10:40:53 -07003089 /**
Michael Jurka7607c2f2013-04-03 14:33:19 -07003090 * If the activity is currently paused, signal that we need to run the passed Runnable
3091 * in onResume.
3092 *
3093 * This needs to be called from incoming places where resources might have been loaded
Hyunyoung Song8821ca92015-05-04 16:28:20 -07003094 * while the activity is paused. That is because the Configuration (e.g., rotation) might be
3095 * wrong when we're not running, and if the activity comes back to what the configuration was
3096 * when we were paused, activity is not restarted.
Michael Jurka7607c2f2013-04-03 14:33:19 -07003097 *
3098 * Implementation of the method from LauncherModel.Callbacks.
3099 *
Hyunyoung Song8821ca92015-05-04 16:28:20 -07003100 * @return {@code true} if we are currently paused. The caller might be able to skip some work
Michael Jurka7607c2f2013-04-03 14:33:19 -07003101 */
Rahul Chaturvedi799aa042015-06-01 21:26:41 -04003102 @Thunk boolean waitUntilResume(Runnable run, boolean deletePreviousRunnables) {
Michael Jurka7607c2f2013-04-03 14:33:19 -07003103 if (mPaused) {
Sunny Goyal2bba4c32015-05-18 15:42:48 -07003104 if (LOGD) Log.d(TAG, "Deferring update until onResume");
Michael Jurkac402cd92013-05-20 15:49:32 +02003105 if (deletePreviousRunnables) {
Michael Jurka1e2f4652013-07-08 18:03:46 -07003106 while (mBindOnResumeCallbacks.remove(run)) {
Michael Jurkac402cd92013-05-20 15:49:32 +02003107 }
3108 }
Michael Jurka1e2f4652013-07-08 18:03:46 -07003109 mBindOnResumeCallbacks.add(run);
Michael Jurka7607c2f2013-04-03 14:33:19 -07003110 return true;
3111 } else {
3112 return false;
3113 }
3114 }
3115
Michael Jurkac402cd92013-05-20 15:49:32 +02003116 private boolean waitUntilResume(Runnable run) {
3117 return waitUntilResume(run, false);
3118 }
3119
Michael Jurka1e2f4652013-07-08 18:03:46 -07003120 public void addOnResumeCallback(Runnable run) {
Michael Jurka54554252013-08-01 12:52:23 +02003121 mOnResumeCallbacks.add(run);
Michael Jurka1e2f4652013-07-08 18:03:46 -07003122 }
3123
Michael Jurka7607c2f2013-04-03 14:33:19 -07003124 /**
Joe Onoratoef2efcf2010-10-27 13:21:00 -07003125 * If the activity is currently paused, signal that we need to re-run the loader
3126 * in onResume.
3127 *
3128 * This needs to be called from incoming places where resources might have been loaded
3129 * while we are paused. That is becaues the Configuration might be wrong
3130 * when we're not running, and if it comes back to what it was when we
3131 * were paused, we are not restarted.
3132 *
3133 * Implementation of the method from LauncherModel.Callbacks.
3134 *
3135 * @return true if we are currently paused. The caller might be able to
3136 * skip some work in that case since we will come back again.
3137 */
Sunny Goyal93f878c2016-03-30 17:31:24 -07003138 @Override
Joe Onoratoef2efcf2010-10-27 13:21:00 -07003139 public boolean setLoadOnResume() {
3140 if (mPaused) {
Sunny Goyal2bba4c32015-05-18 15:42:48 -07003141 if (LOGD) Log.d(TAG, "setLoadOnResume");
Joe Onoratoef2efcf2010-10-27 13:21:00 -07003142 mOnResumeNeedsLoad = true;
3143 return true;
3144 } else {
3145 return false;
3146 }
3147 }
3148
3149 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04003150 * Implementation of the method from LauncherModel.Callbacks.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003151 */
Sunny Goyal93f878c2016-03-30 17:31:24 -07003152 @Override
Joe Onorato9c1289c2009-08-17 11:03:03 -04003153 public int getCurrentWorkspaceScreen() {
Joe Onoratod0afc872010-06-11 00:03:15 -07003154 if (mWorkspace != null) {
Michael Jurka0142d492010-08-25 17:46:15 -07003155 return mWorkspace.getCurrentPage();
Joe Onoratod0afc872010-06-11 00:03:15 -07003156 } else {
Winson Chung882a52e2015-07-08 14:32:26 -07003157 return 0;
Joe Onoratod0afc872010-06-11 00:03:15 -07003158 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04003159 }
The Android Open Source Projectf96811c2009-03-18 17:39:48 -07003160
Joe Onorato9c1289c2009-08-17 11:03:03 -04003161 /**
Sunny Goyal527c7d32015-08-28 15:19:36 -07003162 * Clear any pending bind callbacks. This is called when is loader is planning to
3163 * perform a full rebind from scratch.
3164 */
3165 @Override
3166 public void clearPendingBinds() {
3167 mBindOnResumeCallbacks.clear();
3168 if (mPendingExecutor != null) {
3169 mPendingExecutor.markCompleted();
3170 mPendingExecutor = null;
3171 }
3172 }
3173
3174 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04003175 * Refreshes the shortcuts shown on the workspace.
3176 *
3177 * Implementation of the method from LauncherModel.Callbacks.
3178 */
3179 public void startBinding() {
Sunny Goyale26d1002016-06-20 14:52:14 -07003180 if (LauncherAppState.PROFILE_STARTUP) {
3181 Trace.beginSection("Starting page bind");
3182 }
Jon Miranda6dc7f1e2017-02-21 12:37:51 -08003183
3184 AbstractFloatingView.closeAllOpenViews(this);
3185
Anjali Koppalff7ceff2014-05-01 18:26:37 -07003186 setWorkspaceLoading(true);
Adam Cohen517a7f52014-03-01 12:12:59 -08003187
Winson Chungd64d1762013-08-20 14:37:16 -07003188 // Clear the workspace because it's going to be rebound
Adam Cohendf035382011-04-11 17:22:04 -07003189 mWorkspace.clearDropTargets();
Winson Chung9e6a0a22013-08-27 11:58:12 -07003190 mWorkspace.removeAllWorkspaceScreens();
Winson Chungd64d1762013-08-20 14:37:16 -07003191
Winson Chung3d503fb2011-07-13 17:25:49 -07003192 if (mHotseat != null) {
3193 mHotseat.resetLayout();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003194 }
Sunny Goyale26d1002016-06-20 14:52:14 -07003195 if (LauncherAppState.PROFILE_STARTUP) {
3196 Trace.endSection();
3197 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003198 }
3199
Adam Cohendcd297f2013-06-18 13:13:40 -07003200 @Override
3201 public void bindScreens(ArrayList<Long> orderedScreenIds) {
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07003202 // Make sure the first screen is always at the start.
Sunny Goyala9e2f5a2016-06-10 12:22:04 -07003203 if (FeatureFlags.QSB_ON_FIRST_SCREEN &&
3204 orderedScreenIds.indexOf(Workspace.FIRST_SCREEN_ID) != 0) {
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07003205 orderedScreenIds.remove(Workspace.FIRST_SCREEN_ID);
3206 orderedScreenIds.add(0, Workspace.FIRST_SCREEN_ID);
3207 mModel.updateWorkspaceScreenOrder(this, orderedScreenIds);
Sunny Goyala9e2f5a2016-06-10 12:22:04 -07003208 } else if (!FeatureFlags.QSB_ON_FIRST_SCREEN && orderedScreenIds.isEmpty()) {
3209 // If there are no screens, we need to have an empty screen
3210 mWorkspace.addExtraEmptyScreen();
Adam Cohen5084cba2013-09-03 12:01:16 -07003211 }
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07003212 bindAddScreens(orderedScreenIds);
Winson Chung0e6a7132013-08-23 12:55:10 -07003213
3214 // Create the custom content page (this call updates mDefaultScreen which calls
Dave Hawkeya8881582013-09-17 15:55:33 -06003215 // setCurrentPage() so ensure that all pages are added before calling this).
Derek Prothrodadd9842014-01-17 13:43:50 -05003216 if (hasCustomContentToLeft()) {
3217 mWorkspace.createCustomContentContainer();
3218 populateCustomContentContainer();
Winson Chung0e6a7132013-08-23 12:55:10 -07003219 }
Winsonc7d2e832016-07-28 12:24:55 -07003220
3221 // After we have added all the screens, if the wallpaper was locked to the default state,
3222 // then notify to indicate that it can be released and a proper wallpaper offset can be
3223 // computed before the next layout
3224 mWorkspace.unlockWallpaperFromDefaultPageOnNextLayout();
Winson Chung64359a52013-07-08 17:17:08 -07003225 }
3226
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07003227 private void bindAddScreens(ArrayList<Long> orderedScreenIds) {
Adam Cohendcd297f2013-06-18 13:13:40 -07003228 int count = orderedScreenIds.size();
3229 for (int i = 0; i < count; i++) {
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07003230 long screenId = orderedScreenIds.get(i);
Sunny Goyala9e2f5a2016-06-10 12:22:04 -07003231 if (!FeatureFlags.QSB_ON_FIRST_SCREEN || screenId != Workspace.FIRST_SCREEN_ID) {
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07003232 // No need to bind the first screen, as its always bound.
3233 mWorkspace.insertNewWorkspaceScreenBeforeEmptyScreen(screenId);
3234 }
Adam Cohendcd297f2013-06-18 13:13:40 -07003235 }
Adam Cohendcd297f2013-06-18 13:13:40 -07003236 }
3237
Winson Chungd64d1762013-08-20 14:37:16 -07003238 public void bindAppsAdded(final ArrayList<Long> newScreens,
3239 final ArrayList<ItemInfo> addNotAnimated,
Winson Chungc58497e2013-09-03 17:48:37 -07003240 final ArrayList<ItemInfo> addAnimated,
3241 final ArrayList<AppInfo> addedApps) {
Winson Chungd64d1762013-08-20 14:37:16 -07003242 Runnable r = new Runnable() {
3243 public void run() {
Winson Chungc58497e2013-09-03 17:48:37 -07003244 bindAppsAdded(newScreens, addNotAnimated, addAnimated, addedApps);
Winson Chungd64d1762013-08-20 14:37:16 -07003245 }
3246 };
3247 if (waitUntilResume(r)) {
3248 return;
3249 }
3250
Winson Chungd64d1762013-08-20 14:37:16 -07003251 // Add the new screens
Adam Cohen76a47a12014-02-05 11:47:43 -08003252 if (newScreens != null) {
3253 bindAddScreens(newScreens);
3254 }
Winson Chungd64d1762013-08-20 14:37:16 -07003255
3256 // We add the items without animation on non-visible pages, and with
3257 // animations on the new page (which we will try and snap to).
Adam Cohen76a47a12014-02-05 11:47:43 -08003258 if (addNotAnimated != null && !addNotAnimated.isEmpty()) {
Winson Chungd64d1762013-08-20 14:37:16 -07003259 bindItems(addNotAnimated, 0,
3260 addNotAnimated.size(), false);
3261 }
Adam Cohen76a47a12014-02-05 11:47:43 -08003262 if (addAnimated != null && !addAnimated.isEmpty()) {
Winson Chungd64d1762013-08-20 14:37:16 -07003263 bindItems(addAnimated, 0,
3264 addAnimated.size(), true);
3265 }
Winson Chungc58497e2013-09-03 17:48:37 -07003266
Winson Chung87412982013-10-03 18:34:14 -07003267 // Remove the extra empty screen
Adam Cohen689ff162014-05-08 17:27:56 -07003268 mWorkspace.removeExtraEmptyScreen(false, false);
Winson Chung87412982013-10-03 18:34:14 -07003269
Winson Chungb745afb2015-03-02 11:51:23 -08003270 if (addedApps != null && mAppsView != null) {
3271 mAppsView.addApps(addedApps);
Winson Chungc58497e2013-09-03 17:48:37 -07003272 }
Winson Chungd64d1762013-08-20 14:37:16 -07003273 }
3274
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003275 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04003276 * Bind the items start-end from the list.
3277 *
3278 * Implementation of the method from LauncherModel.Callbacks.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003279 */
Tony Wickham0bb211a2015-10-02 16:22:08 -07003280 @Override
Sunny Goyal3be633b2016-12-08 09:59:25 -08003281 public void bindItems(final ArrayList<ItemInfo> items, final int start, final int end,
Winson Chung64359a52013-07-08 17:17:08 -07003282 final boolean forceAnimateIcons) {
Winson Chungd64d1762013-08-20 14:37:16 -07003283 Runnable r = new Runnable() {
3284 public void run() {
Sunny Goyal3be633b2016-12-08 09:59:25 -08003285 bindItems(items, start, end, forceAnimateIcons);
Winson Chungd64d1762013-08-20 14:37:16 -07003286 }
3287 };
3288 if (waitUntilResume(r)) {
Michael Jurka7607c2f2013-04-03 14:33:19 -07003289 return;
3290 }
Joe Onoratoef2efcf2010-10-27 13:21:00 -07003291
Sunny Goyal3be633b2016-12-08 09:59:25 -08003292 // Get the list of added items and intersect them with the set of items here
Winson Chung64359a52013-07-08 17:17:08 -07003293 final AnimatorSet anim = LauncherAnimUtils.createAnimatorSet();
3294 final Collection<Animator> bounceAnims = new ArrayList<Animator>();
Winson Chung997a9232013-07-24 15:33:46 -07003295 final boolean animateIcons = forceAnimateIcons && canRunNewAppsAnimation();
Winson Chungf0c6ae02012-03-21 16:10:31 -07003296 Workspace workspace = mWorkspace;
Sunny Goyal3be633b2016-12-08 09:59:25 -08003297 long newItemsScreenId = -1;
Winson Chungf0c6ae02012-03-21 16:10:31 -07003298 for (int i = start; i < end; i++) {
Sunny Goyal3be633b2016-12-08 09:59:25 -08003299 final ItemInfo item = items.get(i);
Winson Chung4d279d92011-07-21 11:46:32 -07003300
3301 // Short circuit if we are loading dock items for a configuration which has no dock
3302 if (item.container == LauncherSettings.Favorites.CONTAINER_HOTSEAT &&
3303 mHotseat == null) {
3304 continue;
3305 }
3306
Sunny Goyal639e9062015-08-19 19:17:06 -07003307 final View view;
Joe Onorato9c1289c2009-08-17 11:03:03 -04003308 switch (item.itemType) {
3309 case LauncherSettings.Favorites.ITEM_TYPE_APPLICATION:
3310 case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT:
Sunny Goyal3be633b2016-12-08 09:59:25 -08003311 case LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT: {
Winson Chungf0c6ae02012-03-21 16:10:31 -07003312 ShortcutInfo info = (ShortcutInfo) item;
Sunny Goyal639e9062015-08-19 19:17:06 -07003313 view = createShortcut(info);
Joe Onorato9c1289c2009-08-17 11:03:03 -04003314 break;
Sunny Goyal3be633b2016-12-08 09:59:25 -08003315 }
3316 case LauncherSettings.Favorites.ITEM_TYPE_FOLDER: {
Sunny Goyal639e9062015-08-19 19:17:06 -07003317 view = FolderIcon.fromXml(R.layout.folder_icon, this,
Michael Jurka0142d492010-08-25 17:46:15 -07003318 (ViewGroup) workspace.getChildAt(workspace.getCurrentPage()),
Sunny Goyal1cd01b02016-11-09 10:43:58 -08003319 (FolderInfo) item);
Joe Onorato9c1289c2009-08-17 11:03:03 -04003320 break;
Sunny Goyal3be633b2016-12-08 09:59:25 -08003321 }
3322 case LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET: {
3323 LauncherAppWidgetInfo info = (LauncherAppWidgetInfo) item;
3324 if (mIsSafeModeEnabled) {
3325 view = new PendingAppWidgetHostView(this, info, mIconCache, true);
3326 } else {
3327 LauncherAppWidgetProviderInfo providerInfo =
3328 mAppWidgetManager.getLauncherAppWidgetInfo(info.appWidgetId);
3329 if (providerInfo == null) {
3330 deleteWidgetInfo(info);
3331 continue;
3332 }
3333 view = mAppWidgetHost.createView(this, info.appWidgetId, providerInfo);
3334 }
3335 prepareAppWidget((AppWidgetHostView) view, info);
3336 break;
3337 }
Winson Chungc763c4e2013-07-19 13:49:06 -07003338 default:
3339 throw new RuntimeException("Invalid Item Type");
Joe Onorato9c1289c2009-08-17 11:03:03 -04003340 }
Sunny Goyal639e9062015-08-19 19:17:06 -07003341
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07003342 /*
3343 * Remove colliding items.
3344 */
3345 if (item.container == LauncherSettings.Favorites.CONTAINER_DESKTOP) {
3346 CellLayout cl = mWorkspace.getScreenWithId(item.screenId);
3347 if (cl != null && cl.isOccupied(item.cellX, item.cellY)) {
3348 View v = cl.getChildAt(item.cellX, item.cellY);
3349 Object tag = v.getTag();
3350 String desc = "Collision while binding workspace item: " + item
3351 + ". Collides with " + tag;
Sunny Goyal3d706ad2017-03-06 16:56:39 -08003352 if (FeatureFlags.IS_DOGFOOD_BUILD) {
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07003353 throw (new RuntimeException(desc));
3354 } else {
3355 Log.d(TAG, desc);
Sunny Goyal43bf11d2017-02-02 13:52:53 -08003356 getModelWriter().deleteItemFromDatabase(item);
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07003357 continue;
3358 }
3359 }
3360 }
Sunny Goyald5462aa2016-11-22 16:52:39 +05303361 workspace.addInScreenFromBind(view, item);
Sunny Goyal639e9062015-08-19 19:17:06 -07003362 if (animateIcons) {
3363 // Animate all the applications up now
3364 view.setAlpha(0f);
3365 view.setScaleX(0f);
3366 view.setScaleY(0f);
3367 bounceAnims.add(createNewAppBounceAnimation(view, i));
Sunny Goyal3be633b2016-12-08 09:59:25 -08003368 newItemsScreenId = item.screenId;
Sunny Goyal639e9062015-08-19 19:17:06 -07003369 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003370 }
Winson Chungf0c6ae02012-03-21 16:10:31 -07003371
Winson Chung997a9232013-07-24 15:33:46 -07003372 if (animateIcons) {
3373 // Animate to the correct page
Sunny Goyal3be633b2016-12-08 09:59:25 -08003374 if (newItemsScreenId > -1) {
Winson Chung997a9232013-07-24 15:33:46 -07003375 long currentScreenId = mWorkspace.getScreenIdForPageIndex(mWorkspace.getNextPage());
Sunny Goyal3be633b2016-12-08 09:59:25 -08003376 final int newScreenIndex = mWorkspace.getPageIndexForScreenId(newItemsScreenId);
Winson Chungb2323832013-10-03 15:22:09 -07003377 final Runnable startBounceAnimRunnable = new Runnable() {
3378 public void run() {
3379 anim.playTogether(bounceAnims);
3380 anim.start();
3381 }
3382 };
Sunny Goyal3be633b2016-12-08 09:59:25 -08003383 if (newItemsScreenId != currentScreenId) {
Winson Chung94d67682013-09-25 16:29:40 -07003384 // We post the animation slightly delayed to prevent slowdowns
3385 // when we are loading right after we return to launcher.
3386 mWorkspace.postDelayed(new Runnable() {
3387 public void run() {
Ian Parkinson94449152014-01-21 13:09:59 +00003388 if (mWorkspace != null) {
3389 mWorkspace.snapToPage(newScreenIndex);
3390 mWorkspace.postDelayed(startBounceAnimRunnable,
3391 NEW_APPS_ANIMATION_DELAY);
3392 }
Winson Chung94d67682013-09-25 16:29:40 -07003393 }
3394 }, NEW_APPS_PAGE_MOVE_DELAY);
Winson Chungb2323832013-10-03 15:22:09 -07003395 } else {
3396 mWorkspace.postDelayed(startBounceAnimRunnable, NEW_APPS_ANIMATION_DELAY);
Winson Chung997a9232013-07-24 15:33:46 -07003397 }
3398 }
Winson Chung64359a52013-07-08 17:17:08 -07003399 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04003400 workspace.requestLayout();
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003401 }
3402
Joe Onorato9c1289c2009-08-17 11:03:03 -04003403 /**
3404 * Add the views for a widget to the workspace.
3405 *
3406 * Implementation of the method from LauncherModel.Callbacks.
3407 */
Michael Jurka7607c2f2013-04-03 14:33:19 -07003408 public void bindAppWidget(final LauncherAppWidgetInfo item) {
Winson Chungd64d1762013-08-20 14:37:16 -07003409 Runnable r = new Runnable() {
3410 public void run() {
3411 bindAppWidget(item);
3412 }
3413 };
3414 if (waitUntilResume(r)) {
Michael Jurka7607c2f2013-04-03 14:33:19 -07003415 return;
3416 }
Joe Onoratoef2efcf2010-10-27 13:21:00 -07003417
Sunny Goyal2e1efb42016-03-03 16:58:55 -08003418 if (mIsSafeModeEnabled) {
Sunny Goyald5462aa2016-11-22 16:52:39 +05303419 PendingAppWidgetHostView view =
3420 new PendingAppWidgetHostView(this, item, mIconCache, true);
3421 prepareAppWidget(view, item);
3422 mWorkspace.addInScreen(view, item);
3423 mWorkspace.requestLayout();
Sunny Goyal2e1efb42016-03-03 16:58:55 -08003424 return;
3425 }
3426
Daniel Sandler843e8602010-06-07 14:59:01 -04003427 final long start = DEBUG_WIDGETS ? SystemClock.uptimeMillis() : 0;
3428 if (DEBUG_WIDGETS) {
3429 Log.d(TAG, "bindAppWidget: " + item);
3430 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04003431
Sunny Goyal2e1efb42016-03-03 16:58:55 -08003432 final LauncherAppWidgetProviderInfo appWidgetInfo;
Adam Cohen59400422014-03-05 18:07:04 -08003433
Sunny Goyal2e1efb42016-03-03 16:58:55 -08003434 if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY)) {
3435 // If the provider is not ready, bind as a pending widget.
3436 appWidgetInfo = null;
3437 } else if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)) {
3438 // The widget id is not valid. Try to find the widget based on the provider info.
3439 appWidgetInfo = mAppWidgetManager.findProvider(item.providerName, item.user);
3440 } else {
3441 appWidgetInfo = mAppWidgetManager.getLauncherAppWidgetInfo(item.appWidgetId);
3442 }
Sunny Goyal84b4adc2015-08-12 15:12:16 -07003443
Sunny Goyal2e1efb42016-03-03 16:58:55 -08003444 // If the provider is ready, but the width is not yet restored, try to restore it.
3445 if (!item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY) &&
3446 (item.restoreStatus != LauncherAppWidgetInfo.RESTORE_COMPLETED)) {
Sunny Goyalff572272014-07-23 13:58:07 -07003447 if (appWidgetInfo == null) {
3448 if (DEBUG_WIDGETS) {
3449 Log.d(TAG, "Removing restored widget: id=" + item.appWidgetId
3450 + " belongs to component " + item.providerName
Hyunyoung Song0de01172016-10-05 16:27:48 -07003451 + ", as the provider is null");
Sunny Goyalff572272014-07-23 13:58:07 -07003452 }
Sunny Goyal43bf11d2017-02-02 13:52:53 -08003453 getModelWriter().deleteItemFromDatabase(item);
Sunny Goyalff572272014-07-23 13:58:07 -07003454 return;
3455 }
Sunny Goyalff572272014-07-23 13:58:07 -07003456
Sunny Goyal84b4adc2015-08-12 15:12:16 -07003457 // If we do not have a valid id, try to bind an id.
Sunny Goyal2e1efb42016-03-03 16:58:55 -08003458 if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)) {
Sunny Goyald478c832016-04-01 12:04:16 -07003459 if (!item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_ALLOCATED)) {
3460 // Id has not been allocated yet. Allocate a new id.
3461 item.appWidgetId = mAppWidgetHost.allocateAppWidgetId();
3462 item.restoreStatus |= LauncherAppWidgetInfo.FLAG_ID_ALLOCATED;
Sunny Goyalff572272014-07-23 13:58:07 -07003463
Sunny Goyald478c832016-04-01 12:04:16 -07003464 // Also try to bind the widget. If the bind fails, the user will be shown
3465 // a click to setup UI, which will ask for the bind permission.
Sunny Goyala52ecb02016-12-16 15:04:51 -08003466 PendingAddWidgetInfo pendingInfo = new PendingAddWidgetInfo(appWidgetInfo);
Sunny Goyald478c832016-04-01 12:04:16 -07003467 pendingInfo.spanX = item.spanX;
3468 pendingInfo.spanY = item.spanY;
3469 pendingInfo.minSpanX = item.minSpanX;
3470 pendingInfo.minSpanY = item.minSpanY;
3471 Bundle options = WidgetHostViewLoader.getDefaultOptionsForWidget(this, pendingInfo);
Sunny Goyal86df1382016-08-10 15:03:22 -07003472
3473 boolean isDirectConfig =
3474 item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_DIRECT_CONFIG);
3475 if (isDirectConfig && item.bindOptions != null) {
3476 Bundle newOptions = item.bindOptions.getExtras();
3477 if (options != null) {
3478 newOptions.putAll(options);
3479 }
3480 options = newOptions;
3481 }
Sunny Goyald478c832016-04-01 12:04:16 -07003482 boolean success = mAppWidgetManager.bindAppWidgetIdIfAllowed(
3483 item.appWidgetId, appWidgetInfo, options);
Sunny Goyal84b4adc2015-08-12 15:12:16 -07003484
Sunny Goyal86df1382016-08-10 15:03:22 -07003485 // We tried to bind once. If we were not able to bind, we would need to
3486 // go through the permission dialog, which means we cannot skip the config
3487 // activity.
3488 item.bindOptions = null;
3489 item.restoreStatus &= ~LauncherAppWidgetInfo.FLAG_DIRECT_CONFIG;
3490
Sunny Goyald478c832016-04-01 12:04:16 -07003491 // Bind succeeded
3492 if (success) {
3493 // If the widget has a configure activity, it is still needs to set it up,
3494 // otherwise the widget is ready to go.
Sunny Goyal86df1382016-08-10 15:03:22 -07003495 item.restoreStatus = (appWidgetInfo.configure == null) || isDirectConfig
Sunny Goyald478c832016-04-01 12:04:16 -07003496 ? LauncherAppWidgetInfo.RESTORE_COMPLETED
3497 : LauncherAppWidgetInfo.FLAG_UI_NOT_READY;
Sunny Goyal84b4adc2015-08-12 15:12:16 -07003498 }
Sunny Goyald478c832016-04-01 12:04:16 -07003499
Sunny Goyal43bf11d2017-02-02 13:52:53 -08003500 getModelWriter().updateItemInDatabase(item);
Sunny Goyalff572272014-07-23 13:58:07 -07003501 }
Sunny Goyal2e1efb42016-03-03 16:58:55 -08003502 } else if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_UI_NOT_READY)
Sunny Goyal84b4adc2015-08-12 15:12:16 -07003503 && (appWidgetInfo.configure == null)) {
Sunny Goyal2e1efb42016-03-03 16:58:55 -08003504 // The widget was marked as UI not ready, but there is no configure activity to
3505 // update the UI.
Sunny Goyal84b4adc2015-08-12 15:12:16 -07003506 item.restoreStatus = LauncherAppWidgetInfo.RESTORE_COMPLETED;
Sunny Goyal43bf11d2017-02-02 13:52:53 -08003507 getModelWriter().updateItemInDatabase(item);
Sunny Goyalff572272014-07-23 13:58:07 -07003508 }
Sunny Goyalff572272014-07-23 13:58:07 -07003509 }
3510
Sunny Goyald5462aa2016-11-22 16:52:39 +05303511 final AppWidgetHostView view;
Sunny Goyal2e1efb42016-03-03 16:58:55 -08003512 if (item.restoreStatus == LauncherAppWidgetInfo.RESTORE_COMPLETED) {
Sunny Goyal651077b2014-06-30 14:15:31 -07003513 if (DEBUG_WIDGETS) {
Adam Cohen59400422014-03-05 18:07:04 -08003514 Log.d(TAG, "bindAppWidget: id=" + item.appWidgetId + " belongs to component "
3515 + appWidgetInfo.provider);
Sunny Goyal651077b2014-06-30 14:15:31 -07003516 }
Daniel Sandler843e8602010-06-07 14:59:01 -04003517
Sunny Goyal56c73602015-09-25 12:55:01 -07003518 // Verify that we own the widget
Sunny Goyal2e1efb42016-03-03 16:58:55 -08003519 if (appWidgetInfo == null) {
Sunny Goyal713edfc2016-05-06 09:58:34 -07003520 FileLog.e(TAG, "Removing invalid widget: id=" + item.appWidgetId);
Sunny Goyal56c73602015-09-25 12:55:01 -07003521 deleteWidgetInfo(item);
3522 return;
3523 }
3524
Sunny Goyal233ee962015-08-03 13:05:01 -07003525 item.minSpanX = appWidgetInfo.minSpanX;
3526 item.minSpanY = appWidgetInfo.minSpanY;
Sunny Goyald5462aa2016-11-22 16:52:39 +05303527 view = mAppWidgetHost.createView(this, item.appWidgetId, appWidgetInfo);
Sunny Goyal651077b2014-06-30 14:15:31 -07003528 } else {
Sunny Goyald5462aa2016-11-22 16:52:39 +05303529 view = new PendingAppWidgetHostView(this, item, mIconCache, false);
Sunny Goyal651077b2014-06-30 14:15:31 -07003530 }
Sunny Goyald5462aa2016-11-22 16:52:39 +05303531 prepareAppWidget(view, item);
3532 mWorkspace.addInScreen(view, item);
Sunny Goyal2e1efb42016-03-03 16:58:55 -08003533 mWorkspace.requestLayout();
Joe Onorato9c1289c2009-08-17 11:03:03 -04003534
Daniel Sandler843e8602010-06-07 14:59:01 -04003535 if (DEBUG_WIDGETS) {
3536 Log.d(TAG, "bound widget id="+item.appWidgetId+" in "
3537 + (SystemClock.uptimeMillis()-start) + "ms");
3538 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04003539 }
3540
Sunny Goyalff572272014-07-23 13:58:07 -07003541 /**
3542 * Restores a pending widget.
3543 *
3544 * @param appWidgetId The app widget id
Sunny Goyalff572272014-07-23 13:58:07 -07003545 */
Sunny Goyald478c832016-04-01 12:04:16 -07003546 private LauncherAppWidgetInfo completeRestoreAppWidget(int appWidgetId, int finalRestoreFlag) {
Sunny Goyalff572272014-07-23 13:58:07 -07003547 LauncherAppWidgetHostView view = mWorkspace.getWidgetForAppWidgetId(appWidgetId);
3548 if ((view == null) || !(view instanceof PendingAppWidgetHostView)) {
3549 Log.e(TAG, "Widget update called, when the widget no longer exists.");
Sunny Goyald478c832016-04-01 12:04:16 -07003550 return null;
Sunny Goyalff572272014-07-23 13:58:07 -07003551 }
3552
Sunny Goyal0fc1be12014-08-11 17:05:23 -07003553 LauncherAppWidgetInfo info = (LauncherAppWidgetInfo) view.getTag();
Sunny Goyald478c832016-04-01 12:04:16 -07003554 info.restoreStatus = finalRestoreFlag;
Jon Miranda2b823f42017-05-02 18:36:18 -07003555 if (info.restoreStatus == LauncherAppWidgetInfo.RESTORE_COMPLETED) {
3556 info.pendingItemInfo = null;
3557 }
Sunny Goyalff572272014-07-23 13:58:07 -07003558
3559 mWorkspace.reinflateWidgetsIfNecessary();
Sunny Goyal43bf11d2017-02-02 13:52:53 -08003560 getModelWriter().updateItemInDatabase(info);
Sunny Goyald478c832016-04-01 12:04:16 -07003561 return info;
Sunny Goyalff572272014-07-23 13:58:07 -07003562 }
3563
Adam Cohen1462de32012-07-24 22:34:36 -07003564 public void onPageBoundSynchronously(int page) {
3565 mSynchronouslyBoundPages.add(page);
3566 }
3567
Sunny Goyal527c7d32015-08-28 15:19:36 -07003568 @Override
3569 public void executeOnNextDraw(ViewOnDrawExecutor executor) {
3570 if (mPendingExecutor != null) {
3571 mPendingExecutor.markCompleted();
3572 }
3573 mPendingExecutor = executor;
3574 executor.attachTo(this);
3575 }
3576
3577 public void clearPendingExecutor(ViewOnDrawExecutor executor) {
3578 if (mPendingExecutor == executor) {
3579 mPendingExecutor = null;
3580 }
3581 }
3582
Sunny Goyalb5b9ad62016-04-02 11:23:39 -07003583 @Override
3584 public void finishFirstPageBind(final ViewOnDrawExecutor executor) {
3585 Runnable r = new Runnable() {
3586 public void run() {
3587 finishFirstPageBind(executor);
3588 }
3589 };
3590 if (waitUntilResume(r)) {
3591 return;
3592 }
3593
3594 Runnable onComplete = new Runnable() {
3595 @Override
3596 public void run() {
3597 if (executor != null) {
3598 executor.onLoadAnimationCompleted();
3599 }
3600 }
3601 };
3602 if (mDragLayer.getAlpha() < 1) {
3603 mDragLayer.animate().alpha(1).withEndAction(onComplete).start();
3604 } else {
3605 onComplete.run();
3606 }
3607 }
3608
Joe Onorato9c1289c2009-08-17 11:03:03 -04003609 /**
3610 * Callback saying that there aren't any more items to bind.
3611 *
3612 * Implementation of the method from LauncherModel.Callbacks.
3613 */
Sunny Goyal66cfdc22015-02-02 13:01:51 -08003614 public void finishBindingItems() {
Winson Chungd64d1762013-08-20 14:37:16 -07003615 Runnable r = new Runnable() {
3616 public void run() {
Sunny Goyal66cfdc22015-02-02 13:01:51 -08003617 finishBindingItems();
Winson Chungd64d1762013-08-20 14:37:16 -07003618 }
3619 };
3620 if (waitUntilResume(r)) {
Michael Jurka7607c2f2013-04-03 14:33:19 -07003621 return;
3622 }
Sunny Goyale26d1002016-06-20 14:52:14 -07003623 if (LauncherAppState.PROFILE_STARTUP) {
3624 Trace.beginSection("Page bind completed");
3625 }
Adam Cohen1462de32012-07-24 22:34:36 -07003626 mWorkspace.restoreInstanceStateForRemainingPages();
Joe Onorato9c1289c2009-08-17 11:03:03 -04003627
Anjali Koppalff7ceff2014-05-01 18:26:37 -07003628 setWorkspaceLoading(false);
Adam Cohendb364c32014-05-20 14:23:40 -07003629
Sunny Goyal2100c782016-08-22 16:00:03 -07003630 if (mPendingActivityResult != null) {
3631 handleActivityResult(mPendingActivityResult.requestCode,
3632 mPendingActivityResult.resultCode, mPendingActivityResult.data);
3633 mPendingActivityResult = null;
Adam Cohendb364c32014-05-20 14:23:40 -07003634 }
3635
Sunny Goyal756adbc2015-04-16 15:20:51 -07003636 InstallShortcutReceiver.disableAndFlushInstallQueue(this);
Adam Cohen9211d422014-10-07 18:14:53 -07003637
Tony Wickham010d2552017-01-20 08:15:28 -08003638 NotificationListener.setNotificationsChangedListener(mPopupDataProvider);
3639
Adam Cohen9211d422014-10-07 18:14:53 -07003640 if (mLauncherCallbacks != null) {
Sunny Goyal66cfdc22015-02-02 13:01:51 -08003641 mLauncherCallbacks.finishBindingItems(false);
Adam Cohen9211d422014-10-07 18:14:53 -07003642 }
Sunny Goyale26d1002016-06-20 14:52:14 -07003643 if (LauncherAppState.PROFILE_STARTUP) {
3644 Trace.endSection();
3645 }
Winson Chungf0c6ae02012-03-21 16:10:31 -07003646 }
3647
Winson Chunga2413752012-04-03 14:22:34 -07003648 private boolean canRunNewAppsAnimation() {
3649 long diff = System.currentTimeMillis() - mDragController.getLastGestureUpTime();
Andrew Sapperstein932eb832016-06-30 18:10:09 -07003650 return diff > (NEW_APPS_ANIMATION_INACTIVE_TIMEOUT_SECONDS * 1000);
Winson Chunga2413752012-04-03 14:22:34 -07003651 }
3652
Winson Chungc9168342013-06-26 14:54:55 -07003653 private ValueAnimator createNewAppBounceAnimation(View v, int i) {
Sunny Goyal5d2fc322015-07-06 22:52:49 -07003654 ValueAnimator bounceAnim = LauncherAnimUtils.ofViewAlphaAndScale(v, 1, 1, 1);
Winson Chungc9168342013-06-26 14:54:55 -07003655 bounceAnim.setDuration(InstallShortcutReceiver.NEW_SHORTCUT_BOUNCE_DURATION);
3656 bounceAnim.setStartDelay(i * InstallShortcutReceiver.NEW_SHORTCUT_STAGGER_DELAY);
Sunny Goyal5a1f53b2015-05-27 10:24:24 -07003657 bounceAnim.setInterpolator(new OvershootInterpolator(BOUNCE_ANIMATION_TENSION));
Winson Chungc9168342013-06-26 14:54:55 -07003658 return bounceAnim;
3659 }
3660
Adam Cohen27772732013-11-11 14:00:56 +00003661 public boolean useVerticalBarLayout() {
Sunny Goyaldfaccf62015-05-11 16:30:44 -07003662 return mDeviceProfile.isVerticalBarLayout();
Adam Cohen27772732013-11-11 14:00:56 +00003663 }
3664
Tony Wickham55616cd2015-09-23 14:55:17 -07003665 public int getSearchBarHeight() {
3666 if (mLauncherCallbacks != null) {
3667 return mLauncherCallbacks.getSearchBarHeight();
3668 }
3669 return LauncherCallbacks.SEARCH_BAR_HEIGHT_NORMAL;
3670 }
3671
Amith Yamasani6d7fe502010-11-16 09:05:07 -08003672 /**
Winson Chungbb785c62015-05-05 10:05:08 -07003673 * A runnable that we can dequeue and re-enqueue when all applications are bound (to prevent
3674 * multiple calls to bind the same list.)
3675 */
3676 @Thunk ArrayList<AppInfo> mTmpAppsList;
3677 private Runnable mBindAllApplicationsRunnable = new Runnable() {
3678 public void run() {
3679 bindAllApplications(mTmpAppsList);
3680 mTmpAppsList = null;
3681 }
3682 };
3683
3684 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04003685 * Add the icons for all apps.
3686 *
3687 * Implementation of the method from LauncherModel.Callbacks.
3688 */
Michael Jurkaeadbfc52013-09-04 00:45:37 +02003689 public void bindAllApplications(final ArrayList<AppInfo> apps) {
Winson Chungbb785c62015-05-05 10:05:08 -07003690 if (waitUntilResume(mBindAllApplicationsRunnable, true)) {
3691 mTmpAppsList = apps;
3692 return;
3693 }
3694
Winson Chungb745afb2015-03-02 11:51:23 -08003695 if (mAppsView != null) {
3696 mAppsView.setApps(apps);
3697 }
Adam Cohen9211d422014-10-07 18:14:53 -07003698 if (mLauncherCallbacks != null) {
3699 mLauncherCallbacks.bindAllApplications(apps);
3700 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04003701 }
3702
3703 /**
Tony Wickhambfbf7f92016-05-19 11:19:39 -07003704 * Copies LauncherModel's map of activities to shortcut ids to Launcher's. This is necessary
3705 * because LauncherModel's map is updated in the background, while Launcher runs on the UI.
3706 */
3707 @Override
3708 public void bindDeepShortcutMap(MultiHashMap<ComponentKey, String> deepShortcutMapCopy) {
Tony Wickham010d2552017-01-20 08:15:28 -08003709 mPopupDataProvider.setDeepShortcutMap(deepShortcutMapCopy);
Tony Wickham1bce7fd2016-04-28 17:39:03 -07003710 }
3711
Tony Wickhambfbf7f92016-05-19 11:19:39 -07003712 /**
Joe Onorato9c1289c2009-08-17 11:03:03 -04003713 * A package was updated.
3714 *
3715 * Implementation of the method from LauncherModel.Callbacks.
3716 */
Michael Jurkaeadbfc52013-09-04 00:45:37 +02003717 public void bindAppsUpdated(final ArrayList<AppInfo> apps) {
Winson Chungd64d1762013-08-20 14:37:16 -07003718 Runnable r = new Runnable() {
3719 public void run() {
3720 bindAppsUpdated(apps);
3721 }
3722 };
3723 if (waitUntilResume(r)) {
Michael Jurka7607c2f2013-04-03 14:33:19 -07003724 return;
3725 }
3726
Winson Chungb745afb2015-03-02 11:51:23 -08003727 if (mAppsView != null) {
3728 mAppsView.updateApps(apps);
Winson Chungc58497e2013-09-03 17:48:37 -07003729 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04003730 }
3731
Sunny Goyal4390ace2014-10-13 11:33:11 -07003732 @Override
Mario Bertschler08ffaae2017-03-20 11:30:27 -07003733 public void bindPromiseAppProgressUpdated(final PromiseAppInfo app) {
3734 Runnable r = new Runnable() {
3735 public void run() {
3736 bindPromiseAppProgressUpdated(app);
3737 }
3738 };
3739 if (waitUntilResume(r)) {
3740 return;
3741 }
3742
3743 if (mAppsView != null) {
3744 mAppsView.updatePromiseAppProgress(app);
3745 }
3746 }
3747
3748 @Override
Sunny Goyal4390ace2014-10-13 11:33:11 -07003749 public void bindWidgetsRestored(final ArrayList<LauncherAppWidgetInfo> widgets) {
3750 Runnable r = new Runnable() {
3751 public void run() {
3752 bindWidgetsRestored(widgets);
3753 }
3754 };
3755 if (waitUntilResume(r)) {
3756 return;
3757 }
3758 mWorkspace.widgetsRestored(widgets);
3759 }
3760
Joe Onorato9c1289c2009-08-17 11:03:03 -04003761 /**
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07003762 * Some shortcuts were updated in the background.
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07003763 * Implementation of the method from LauncherModel.Callbacks.
Sunny Goyald3b87ef2016-07-28 12:11:54 -07003764 *
3765 * @param updated list of shortcuts which have changed.
3766 * @param removed list of shortcuts which were deleted in the background. This can happen when
3767 * an app gets removed from the system or some of its components are no longer
3768 * available.
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07003769 */
Sunny Goyal4390ace2014-10-13 11:33:11 -07003770 @Override
3771 public void bindShortcutsChanged(final ArrayList<ShortcutInfo> updated,
Sunny Goyal7c74e4a2016-12-15 15:53:17 -08003772 final ArrayList<ShortcutInfo> removed, final UserHandle user) {
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07003773 Runnable r = new Runnable() {
3774 public void run() {
Sunny Goyal4390ace2014-10-13 11:33:11 -07003775 bindShortcutsChanged(updated, removed, user);
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07003776 }
3777 };
3778 if (waitUntilResume(r)) {
3779 return;
3780 }
3781
Sunny Goyal4390ace2014-10-13 11:33:11 -07003782 if (!updated.isEmpty()) {
3783 mWorkspace.updateShortcuts(updated);
3784 }
3785
3786 if (!removed.isEmpty()) {
Sunny Goyald3b87ef2016-07-28 12:11:54 -07003787 HashSet<ComponentName> removedComponents = new HashSet<>();
3788 HashSet<ShortcutKey> removedDeepShortcuts = new HashSet<>();
3789
Sunny Goyal4390ace2014-10-13 11:33:11 -07003790 for (ShortcutInfo si : removed) {
Sunny Goyald3b87ef2016-07-28 12:11:54 -07003791 if (si.itemType == Favorites.ITEM_TYPE_DEEP_SHORTCUT) {
Sunny Goyal3fe4a142016-12-15 17:40:07 -08003792 removedDeepShortcuts.add(ShortcutKey.fromItemInfo(si));
Sunny Goyald3b87ef2016-07-28 12:11:54 -07003793 } else {
3794 removedComponents.add(si.getTargetComponent());
3795 }
Sunny Goyal4390ace2014-10-13 11:33:11 -07003796 }
Sunny Goyald3b87ef2016-07-28 12:11:54 -07003797
3798 if (!removedComponents.isEmpty()) {
3799 ItemInfoMatcher matcher = ItemInfoMatcher.ofComponents(removedComponents, user);
3800 mWorkspace.removeItemsByMatcher(matcher);
3801 mDragController.onAppsRemoved(matcher);
3802 }
3803
3804 if (!removedDeepShortcuts.isEmpty()) {
3805 ItemInfoMatcher matcher = ItemInfoMatcher.ofShortcutKeys(removedDeepShortcuts);
3806 mWorkspace.removeItemsByMatcher(matcher);
3807 mDragController.onAppsRemoved(matcher);
3808 }
Sunny Goyalb50cc8c2014-10-06 16:23:56 -07003809 }
3810 }
3811
3812 /**
Chris Wrenaeff7ea2014-02-14 16:59:24 -05003813 * Update the state of a package, typically related to install state.
3814 *
3815 * Implementation of the method from LauncherModel.Callbacks.
3816 */
Sunny Goyale755d462014-07-22 13:48:29 -07003817 @Override
Sunny Goyal756adbc2015-04-16 15:20:51 -07003818 public void bindRestoreItemsChange(final HashSet<ItemInfo> updates) {
3819 Runnable r = new Runnable() {
3820 public void run() {
3821 bindRestoreItemsChange(updates);
3822 }
3823 };
3824 if (waitUntilResume(r)) {
3825 return;
Chris Wrenaeff7ea2014-02-14 16:59:24 -05003826 }
Chris Wrenaeff7ea2014-02-14 16:59:24 -05003827
Sunny Goyal756adbc2015-04-16 15:20:51 -07003828 mWorkspace.updateRestoreItems(updates);
Sunny Goyala22666f2014-09-18 13:25:15 -07003829 }
3830
3831 /**
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07003832 * A package was uninstalled/updated. We take both the super set of packageNames
Winson Chung83892cc2013-05-01 16:53:33 -07003833 * in addition to specific applications to remove, the reason being that
3834 * this can be called when a package is updated as well. In that scenario,
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07003835 * we only remove specific components from the workspace and hotseat, where as
Winson Chung83892cc2013-05-01 16:53:33 -07003836 * package-removal should clear all items by package name.
Joe Onorato9c1289c2009-08-17 11:03:03 -04003837 */
Sunny Goyal1a745e82014-10-02 15:58:31 -07003838 @Override
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07003839 public void bindWorkspaceComponentsRemoved(
3840 final HashSet<String> packageNames, final HashSet<ComponentName> components,
Sunny Goyal7c74e4a2016-12-15 15:53:17 -08003841 final UserHandle user) {
Winson Chungd64d1762013-08-20 14:37:16 -07003842 Runnable r = new Runnable() {
Winson Chung83892cc2013-05-01 16:53:33 -07003843 public void run() {
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07003844 bindWorkspaceComponentsRemoved(packageNames, components, user);
Winson Chung83892cc2013-05-01 16:53:33 -07003845 }
Winson Chungd64d1762013-08-20 14:37:16 -07003846 };
3847 if (waitUntilResume(r)) {
Winson Chung83892cc2013-05-01 16:53:33 -07003848 return;
3849 }
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07003850 if (!packageNames.isEmpty()) {
Sunny Goyald3b87ef2016-07-28 12:11:54 -07003851 ItemInfoMatcher matcher = ItemInfoMatcher.ofPackages(packageNames, user);
3852 mWorkspace.removeItemsByMatcher(matcher);
3853 mDragController.onAppsRemoved(matcher);
3854
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07003855 }
3856 if (!components.isEmpty()) {
Sunny Goyald3b87ef2016-07-28 12:11:54 -07003857 ItemInfoMatcher matcher = ItemInfoMatcher.ofComponents(components, user);
3858 mWorkspace.removeItemsByMatcher(matcher);
3859 mDragController.onAppsRemoved(matcher);
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07003860 }
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07003861 }
Sunny Goyal4390ace2014-10-13 11:33:11 -07003862
Sunny Goyal3bbbabc2016-03-15 09:16:30 -07003863 @Override
3864 public void bindAppInfosRemoved(final ArrayList<AppInfo> appInfos) {
3865 Runnable r = new Runnable() {
3866 public void run() {
3867 bindAppInfosRemoved(appInfos);
3868 }
3869 };
3870 if (waitUntilResume(r)) {
3871 return;
Joe Onorato36115782010-06-17 13:28:48 -04003872 }
Winson Chungf0ea4d32011-06-06 14:27:16 -07003873
Winson Chungdf95eb12013-10-16 14:57:07 -07003874 // Update AllApps
Winson Chungb745afb2015-03-02 11:51:23 -08003875 if (mAppsView != null) {
3876 mAppsView.removeApps(appInfos);
Hyunyoung Song51114f22017-05-02 16:06:28 -07003877 tryAndUpdatePredictedApps();
Winson Chungc58497e2013-09-03 17:48:37 -07003878 }
Joe Onorato9c1289c2009-08-17 11:03:03 -04003879 }
Joe Onoratobe386092009-11-17 17:32:16 -08003880
Sunny Goyald164b7f2016-10-12 20:49:31 -07003881 private Runnable mBindAllWidgetsRunnable = new Runnable() {
Winson Chung83892cc2013-05-01 16:53:33 -07003882 public void run() {
Sunny Goyald164b7f2016-10-12 20:49:31 -07003883 bindAllWidgets(mAllWidgets);
Winson Chung83892cc2013-05-01 16:53:33 -07003884 }
Michael Jurkac402cd92013-05-20 15:49:32 +02003885 };
Hyunyoung Song3f471442015-04-08 19:01:34 -07003886
Hyunyoung Song8821ca92015-05-04 16:28:20 -07003887 @Override
Sunny Goyald164b7f2016-10-12 20:49:31 -07003888 public void bindAllWidgets(MultiHashMap<PackageItemInfo, WidgetItem> allWidgets) {
3889 if (waitUntilResume(mBindAllWidgetsRunnable, true)) {
3890 mAllWidgets = allWidgets;
Winson Chung83892cc2013-05-01 16:53:33 -07003891 return;
3892 }
3893
Sunny Goyald164b7f2016-10-12 20:49:31 -07003894 if (mWidgetsView != null && allWidgets != null) {
3895 mWidgetsView.setWidgets(allWidgets);
3896 mAllWidgets = null;
Winson Chung785d2eb2011-04-14 16:08:02 -07003897 }
Tony Wickham26b17462017-03-20 17:12:24 -07003898
3899 AbstractFloatingView topView = AbstractFloatingView.getTopOpenView(this);
3900 if (topView != null) {
3901 topView.onWidgetsBound();
3902 }
3903 }
3904
3905 public List<WidgetItem> getWidgetsForPackageUser(PackageUserKey packageUserKey) {
3906 return mWidgetsView.getWidgetsForPackageUser(packageUserKey);
Winson Chung80baf5a2010-08-09 16:03:15 -07003907 }
3908
Sunny Goyal2e1efb42016-03-03 16:58:55 -08003909 @Override
3910 public void notifyWidgetProvidersChanged() {
Tony Wickham86222d22017-03-29 15:30:43 -07003911 if (mWorkspace.getState().shouldUpdateWidget) {
3912 refreshAndBindWidgetsForPackageUser(null);
3913 }
Tony Wickham26b17462017-03-20 17:12:24 -07003914 }
3915
Tony Wickham86222d22017-03-29 15:30:43 -07003916 /**
3917 * @param packageUser if null, refreshes all widgets and shortcuts, otherwise only
3918 * refreshes the widgets and shortcuts associated with the given package/user
3919 */
3920 public void refreshAndBindWidgetsForPackageUser(@Nullable PackageUserKey packageUser) {
3921 mModel.refreshAndBindWidgetsAndShortcuts(this, mWidgetsView.isEmpty(), packageUser);
Sunny Goyal2e1efb42016-03-03 16:58:55 -08003922 }
3923
Winson Chung4b919f82012-05-01 10:44:08 -07003924 public void lockScreenOrientation() {
Rahul Chaturvedi7fc77ca2015-05-19 18:02:16 -07003925 if (mRotationEnabled) {
Sunny Goyala52ecb02016-12-16 15:04:51 -08003926 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LOCKED);
Winson Chung4b919f82012-05-01 10:44:08 -07003927 }
3928 }
Rahul Chaturvedi7fc77ca2015-05-19 18:02:16 -07003929
Winson Chung4b919f82012-05-01 10:44:08 -07003930 public void unlockScreenOrientation(boolean immediate) {
Rahul Chaturvedi7fc77ca2015-05-19 18:02:16 -07003931 if (mRotationEnabled) {
Winson Chung4b919f82012-05-01 10:44:08 -07003932 if (immediate) {
Winson Chung641d71d2012-04-26 15:58:01 -07003933 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
Winson Chung4b919f82012-05-01 10:44:08 -07003934 } else {
3935 mHandler.postDelayed(new Runnable() {
3936 public void run() {
3937 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
3938 }
Sunny Goyal756cd262015-08-20 12:33:21 -07003939 }, RESTORE_SCREEN_ORIENTATION_DELAY);
Winson Chung641d71d2012-04-26 15:58:01 -07003940 }
Winson Chung4b919f82012-05-01 10:44:08 -07003941 }
Winson Chung400438b2011-01-16 17:53:48 -08003942 }
3943
Hyunyoung Songc001cf52016-07-21 17:32:43 -07003944 private void markAppsViewShown() {
3945 if (mSharedPrefs.getBoolean(APPS_VIEW_SHOWN, false)) {
3946 return;
3947 }
3948 mSharedPrefs.edit().putBoolean(APPS_VIEW_SHOWN, true).apply();
3949 }
3950
3951 private boolean shouldShowDiscoveryBounce() {
3952 if (mState != mState.WORKSPACE) {
3953 return false;
3954 }
3955 if (mLauncherCallbacks != null && mLauncherCallbacks.shouldShowDiscoveryBounce()) {
3956 return true;
3957 }
3958 if (!mIsResumeFromActionScreenOff) {
3959 return false;
3960 }
3961 if (mSharedPrefs.getBoolean(APPS_VIEW_SHOWN, false)) {
3962 return false;
3963 }
3964 return true;
3965 }
3966
Winson Chung5ffd51d2015-06-25 11:36:50 -07003967 protected void moveWorkspaceToDefaultScreen() {
3968 mWorkspace.moveToDefaultScreen(false);
3969 }
3970
Winson Chung80baf5a2010-08-09 16:03:15 -07003971 /**
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08003972 * $ adb shell dumpsys activity com.android.launcher3.Launcher [--all]
Joe Onoratobe386092009-11-17 17:32:16 -08003973 */
Adam Cohen16d7ffc2011-10-05 17:49:14 -07003974 @Override
3975 public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) {
3976 super.dump(prefix, fd, writer, args);
Sunny Goyala1365452015-10-01 15:46:24 -07003977
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08003978 if (args.length > 0 && TextUtils.equals(args[0], "--all")) {
3979 writer.println(prefix + "Workspace Items");
3980 for (int i = mWorkspace.numCustomPages(); i < mWorkspace.getPageCount(); i++) {
3981 writer.println(prefix + " Homescreen " + i);
3982
3983 ViewGroup layout = ((CellLayout) mWorkspace.getPageAt(i)).getShortcutsAndWidgets();
3984 for (int j = 0; j < layout.getChildCount(); j++) {
3985 Object tag = layout.getChildAt(j).getTag();
3986 if (tag != null) {
3987 writer.println(prefix + " " + tag.toString());
3988 }
3989 }
3990 }
3991
3992 writer.println(prefix + " Hotseat");
3993 ViewGroup layout = mHotseat.getLayout().getShortcutsAndWidgets();
Sunny Goyala1365452015-10-01 15:46:24 -07003994 for (int j = 0; j < layout.getChildCount(); j++) {
3995 Object tag = layout.getChildAt(j).getTag();
3996 if (tag != null) {
3997 writer.println(prefix + " " + tag.toString());
3998 }
Adam Cohen4caf2982013-08-20 18:54:31 -07003999 }
Sunny Goyala1365452015-10-01 15:46:24 -07004000
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08004001 try {
4002 FileLog.flushAll(writer);
4003 } catch (Exception e) {
4004 // Ignore
Sunny Goyala1365452015-10-01 15:46:24 -07004005 }
4006 }
4007
Hyunyoung Song3c7d9cb2017-01-30 15:11:27 -08004008 writer.println(prefix + "Misc:");
4009 writer.print(prefix + "\tmWorkspaceLoading=" + mWorkspaceLoading);
4010 writer.print(" mPendingRequestArgs=" + mPendingRequestArgs);
4011 writer.println(" mPendingActivityResult=" + mPendingActivityResult);
4012
4013 mModel.dumpState(prefix, fd, writer, args);
Sunny Goyala1365452015-10-01 15:46:24 -07004014
Adam Cohen9211d422014-10-07 18:14:53 -07004015 if (mLauncherCallbacks != null) {
4016 mLauncherCallbacks.dump(prefix, fd, writer, args);
4017 }
Adam Cohen16d7ffc2011-10-05 17:49:14 -07004018 }
Adam Cohen487f7dd2012-06-28 18:12:10 -07004019
Sunny Goyal66b24572016-09-21 15:57:55 -07004020 @Override
4021 @TargetApi(Build.VERSION_CODES.N)
4022 public void onProvideKeyboardShortcuts(
4023 List<KeyboardShortcutGroup> data, Menu menu, int deviceId) {
4024
4025 ArrayList<KeyboardShortcutInfo> shortcutInfos = new ArrayList<>();
4026 if (mState == State.WORKSPACE) {
4027 shortcutInfos.add(new KeyboardShortcutInfo(getString(R.string.all_apps_button_label),
4028 KeyEvent.KEYCODE_A, KeyEvent.META_CTRL_ON));
4029 }
4030 View currentFocus = getCurrentFocus();
4031 if (new CustomActionsPopup(this, currentFocus).canShow()) {
4032 shortcutInfos.add(new KeyboardShortcutInfo(getString(R.string.custom_actions),
4033 KeyEvent.KEYCODE_O, KeyEvent.META_CTRL_ON));
4034 }
4035 if (currentFocus instanceof BubbleTextView &&
4036 ((BubbleTextView) currentFocus).hasDeepShortcuts()) {
4037 shortcutInfos.add(new KeyboardShortcutInfo(getString(R.string.action_deep_shortcut),
4038 KeyEvent.KEYCODE_S, KeyEvent.META_CTRL_ON));
4039 }
4040 if (!shortcutInfos.isEmpty()) {
4041 data.add(new KeyboardShortcutGroup(getString(R.string.home_screen), shortcutInfos));
4042 }
4043
4044 super.onProvideKeyboardShortcuts(data, menu, deviceId);
4045 }
4046
4047 @Override
4048 public boolean onKeyShortcut(int keyCode, KeyEvent event) {
4049 if (event.hasModifiers(KeyEvent.META_CTRL_ON)) {
4050 switch (keyCode) {
4051 case KeyEvent.KEYCODE_A:
4052 if (mState == State.WORKSPACE) {
4053 showAppsView(true, true, false);
4054 return true;
4055 }
4056 break;
4057 case KeyEvent.KEYCODE_S: {
4058 View focusedView = getCurrentFocus();
4059 if (focusedView instanceof BubbleTextView
4060 && focusedView.getTag() instanceof ItemInfo
4061 && mAccessibilityDelegate.performAction(focusedView,
4062 (ItemInfo) focusedView.getTag(),
4063 LauncherAccessibilityDelegate.DEEP_SHORTCUTS)) {
Tony Wickham540913e2017-01-23 11:47:51 -08004064 PopupContainerWithArrow.getOpen(this).requestFocus();
Sunny Goyal66b24572016-09-21 15:57:55 -07004065 return true;
4066 }
4067 break;
4068 }
4069 case KeyEvent.KEYCODE_O:
4070 if (new CustomActionsPopup(this, getCurrentFocus()).show()) {
4071 return true;
4072 }
4073 break;
4074 }
4075 }
4076 return super.onKeyShortcut(keyCode, event);
4077 }
4078
Adam Cohen59400422014-03-05 18:07:04 -08004079 public static CustomAppWidget getCustomAppWidget(String name) {
4080 return sCustomAppWidgets.get(name);
4081 }
4082
4083 public static HashMap<String, CustomAppWidget> getCustomAppWidgets() {
4084 return sCustomAppWidgets;
4085 }
4086
Andrew Sappersteinabef55a2016-06-19 12:49:00 -07004087 public static Launcher getLauncher(Context context) {
4088 if (context instanceof Launcher) {
4089 return (Launcher) context;
4090 }
4091 return ((Launcher) ((ContextWrapper) context).getBaseContext());
4092 }
4093
Sunny Goyal5a81c382017-03-20 15:08:06 -07004094 private class RotationPrefChangeHandler implements OnSharedPreferenceChangeListener {
Sunny Goyal745bad92016-05-02 10:54:12 -07004095
4096 @Override
4097 public void onSharedPreferenceChanged(
4098 SharedPreferences sharedPreferences, String key) {
4099 if (Utilities.ALLOW_ROTATION_PREFERENCE_KEY.equals(key)) {
Sunny Goyal5a81c382017-03-20 15:08:06 -07004100 // Finish this instance of the activity. When the activity is recreated,
4101 // it will initialize the rotation preference again.
4102 finish();
Sunny Goyal745bad92016-05-02 10:54:12 -07004103 }
4104 }
Sunny Goyal745bad92016-05-02 10:54:12 -07004105 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08004106}