| /* |
| * Copyright (C) 2008 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.launcher3; |
| |
| import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_NOSENSOR; |
| import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED; |
| |
| import static com.android.launcher3.LauncherAnimUtils.SPRING_LOADED_EXIT_DELAY; |
| import static com.android.launcher3.LauncherState.ALL_APPS; |
| import static com.android.launcher3.LauncherState.NORMAL; |
| import static com.android.launcher3.LauncherState.OVERVIEW; |
| import static com.android.launcher3.logging.LoggerUtils.newContainerTarget; |
| import static com.android.launcher3.util.RunnableWithId.RUNNABLE_ID_BIND_APPS; |
| import static com.android.launcher3.util.RunnableWithId.RUNNABLE_ID_BIND_WIDGETS; |
| |
| import android.Manifest; |
| import android.animation.Animator; |
| import android.animation.AnimatorListenerAdapter; |
| import android.animation.AnimatorSet; |
| import android.animation.ObjectAnimator; |
| import android.animation.ValueAnimator; |
| import android.annotation.SuppressLint; |
| import android.annotation.TargetApi; |
| import android.app.ActivityOptions; |
| import android.app.AlertDialog; |
| import android.app.SearchManager; |
| import android.appwidget.AppWidgetHostView; |
| import android.appwidget.AppWidgetManager; |
| import android.content.ActivityNotFoundException; |
| import android.content.BroadcastReceiver; |
| import android.content.ComponentCallbacks2; |
| import android.content.ComponentName; |
| import android.content.Context; |
| import android.content.ContextWrapper; |
| import android.content.DialogInterface; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.content.IntentSender; |
| import android.content.SharedPreferences; |
| import android.content.SharedPreferences.OnSharedPreferenceChangeListener; |
| import android.content.pm.PackageManager; |
| import android.database.sqlite.SQLiteDatabase; |
| import android.graphics.Point; |
| import android.graphics.Rect; |
| import android.graphics.drawable.Drawable; |
| import android.os.AsyncTask; |
| import android.os.Build; |
| import android.os.Bundle; |
| import android.os.Parcelable; |
| import android.os.Process; |
| import android.os.StrictMode; |
| import android.os.UserHandle; |
| import android.support.annotation.Nullable; |
| import android.text.Selection; |
| import android.text.SpannableStringBuilder; |
| import android.text.TextUtils; |
| import android.text.method.TextKeyListener; |
| import android.util.Log; |
| import android.util.SparseArray; |
| import android.view.Display; |
| import android.view.HapticFeedbackConstants; |
| import android.view.KeyEvent; |
| import android.view.KeyboardShortcutGroup; |
| import android.view.KeyboardShortcutInfo; |
| import android.view.LayoutInflater; |
| import android.view.Menu; |
| import android.view.MotionEvent; |
| import android.view.View; |
| import android.view.View.OnLongClickListener; |
| import android.view.ViewGroup; |
| import android.view.accessibility.AccessibilityEvent; |
| import android.view.accessibility.AccessibilityManager; |
| import android.view.animation.OvershootInterpolator; |
| import android.view.inputmethod.InputMethodManager; |
| import android.widget.Toast; |
| |
| import com.android.launcher3.DropTarget.DragObject; |
| import com.android.launcher3.LauncherSettings.Favorites; |
| import com.android.launcher3.Workspace.ItemOperator; |
| import com.android.launcher3.accessibility.LauncherAccessibilityDelegate; |
| import com.android.launcher3.allapps.AllAppsContainerView; |
| import com.android.launcher3.allapps.AllAppsTransitionController; |
| import com.android.launcher3.compat.AppWidgetManagerCompat; |
| import com.android.launcher3.compat.LauncherAppsCompat; |
| import com.android.launcher3.compat.LauncherAppsCompatVO; |
| import com.android.launcher3.compat.UserManagerCompat; |
| import com.android.launcher3.config.FeatureFlags; |
| import com.android.launcher3.dragndrop.DragController; |
| import com.android.launcher3.dragndrop.DragLayer; |
| import com.android.launcher3.dragndrop.DragOptions; |
| import com.android.launcher3.dragndrop.DragView; |
| import com.android.launcher3.dragndrop.PinItemDragListener; |
| import com.android.launcher3.dynamicui.WallpaperColorInfo; |
| import com.android.launcher3.folder.Folder; |
| import com.android.launcher3.folder.FolderIcon; |
| import com.android.launcher3.keyboard.CustomActionsPopup; |
| import com.android.launcher3.keyboard.ViewGroupFocusHelper; |
| import com.android.launcher3.logging.FileLog; |
| import com.android.launcher3.logging.UserEventDispatcher; |
| import com.android.launcher3.model.ModelWriter; |
| import com.android.launcher3.notification.NotificationListener; |
| import com.android.launcher3.pageindicators.PageIndicator; |
| import com.android.launcher3.popup.BaseActionPopup; |
| import com.android.launcher3.popup.PopupContainerWithArrow; |
| import com.android.launcher3.popup.PopupDataProvider; |
| import com.android.launcher3.shortcuts.DeepShortcutManager; |
| import com.android.launcher3.states.AllAppsState; |
| import com.android.launcher3.userevent.nano.LauncherLogProto; |
| import com.android.launcher3.userevent.nano.LauncherLogProto.Action; |
| import com.android.launcher3.userevent.nano.LauncherLogProto.ContainerType; |
| import com.android.launcher3.userevent.nano.LauncherLogProto.ControlType; |
| import com.android.launcher3.userevent.nano.LauncherLogProto.Target; |
| import com.android.launcher3.util.ActivityResultInfo; |
| import com.android.launcher3.util.ComponentKey; |
| import com.android.launcher3.util.ItemInfoMatcher; |
| import com.android.launcher3.util.MultiHashMap; |
| import com.android.launcher3.util.PackageManagerHelper; |
| import com.android.launcher3.util.PackageUserKey; |
| import com.android.launcher3.util.PendingRequestArgs; |
| import com.android.launcher3.util.RunnableWithId; |
| import com.android.launcher3.util.SystemUiController; |
| import com.android.launcher3.util.TestingUtils; |
| import com.android.launcher3.util.Themes; |
| import com.android.launcher3.util.Thunk; |
| import com.android.launcher3.util.TraceHelper; |
| import com.android.launcher3.util.UiThreadHelper; |
| import com.android.launcher3.util.ViewOnDrawExecutor; |
| import com.android.launcher3.widget.PendingAddShortcutInfo; |
| import com.android.launcher3.widget.PendingAddWidgetInfo; |
| import com.android.launcher3.widget.WidgetAddFlowHandler; |
| import com.android.launcher3.widget.WidgetHostViewLoader; |
| import com.android.launcher3.widget.WidgetListRowEntry; |
| import com.android.launcher3.widget.WidgetsFullSheet; |
| import com.android.launcher3.widget.custom.CustomWidgetParser; |
| |
| import java.io.FileDescriptor; |
| import java.io.PrintWriter; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| import java.util.concurrent.Executor; |
| |
| /** |
| * Default launcher application. |
| */ |
| public class Launcher extends BaseActivity |
| implements LauncherExterns, View.OnClickListener, OnLongClickListener, |
| LauncherModel.Callbacks, View.OnTouchListener, LauncherProviderChangeListener, |
| AccessibilityManager.AccessibilityStateChangeListener, |
| WallpaperColorInfo.OnThemeChangeListener { |
| public static final String TAG = "Launcher"; |
| static final boolean LOGD = false; |
| |
| static final boolean DEBUG_STRICT_MODE = false; |
| |
| private static final int REQUEST_CREATE_SHORTCUT = 1; |
| private static final int REQUEST_CREATE_APPWIDGET = 5; |
| |
| private static final int REQUEST_PICK_APPWIDGET = 9; |
| private static final int REQUEST_PICK_WALLPAPER = 10; |
| |
| private static final int REQUEST_BIND_APPWIDGET = 11; |
| private static final int REQUEST_BIND_PENDING_APPWIDGET = 12; |
| private static final int REQUEST_RECONFIGURE_APPWIDGET = 13; |
| |
| private static final int REQUEST_PERMISSION_CALL_PHONE = 14; |
| |
| private static final float BOUNCE_ANIMATION_TENSION = 1.3f; |
| |
| /** |
| * IntentStarter uses request codes starting with this. This must be greater than all activity |
| * request codes used internally. |
| */ |
| protected static final int REQUEST_LAST = 100; |
| |
| // The Intent extra that defines whether to ignore the launch animation |
| static final String INTENT_EXTRA_IGNORE_LAUNCH_ANIMATION = |
| "com.android.launcher3.intent.extra.shortcut.INGORE_LAUNCH_ANIMATION"; |
| |
| // Type: int |
| private static final String RUNTIME_STATE_CURRENT_SCREEN = "launcher.current_screen"; |
| // Type: int |
| private static final String RUNTIME_STATE = "launcher.state"; |
| // Type: PendingRequestArgs |
| private static final String RUNTIME_STATE_PENDING_REQUEST_ARGS = "launcher.request_args"; |
| // Type: ActivityResultInfo |
| private static final String RUNTIME_STATE_PENDING_ACTIVITY_RESULT = "launcher.activity_result"; |
| // Type: SparseArray<Parcelable> |
| private static final String RUNTIME_STATE_WIDGET_PANEL = "launcher.widget_panel"; |
| |
| private LauncherStateManager mStateManager; |
| |
| private boolean mIsSafeModeEnabled; |
| |
| private static final int ON_ACTIVITY_RESULT_ANIMATION_DELAY = 500; |
| |
| // How long to wait before the new-shortcut animation automatically pans the workspace |
| private static final int NEW_APPS_PAGE_MOVE_DELAY = 500; |
| private static final int NEW_APPS_ANIMATION_INACTIVE_TIMEOUT_SECONDS = 5; |
| @Thunk static final int NEW_APPS_ANIMATION_DELAY = 500; |
| |
| @Thunk Workspace mWorkspace; |
| private View mLauncherView; |
| @Thunk DragLayer mDragLayer; |
| private DragController mDragController; |
| |
| public View mWeightWatcher; |
| |
| private AppWidgetManagerCompat mAppWidgetManager; |
| private LauncherAppWidgetHost mAppWidgetHost; |
| |
| private final int[] mTmpAddItemCellCoordinates = new int[2]; |
| |
| @Thunk Hotseat mHotseat; |
| private ViewGroup mOverviewPanel; |
| |
| private View mAllAppsButton; |
| |
| private DropTargetBar mDropTargetBar; |
| |
| // Main container view for the all apps screen. |
| @Thunk AllAppsContainerView mAppsView; |
| AllAppsTransitionController mAllAppsController; |
| |
| // We need to store the orientation Launcher was created with, due to a bug (b/64916689) |
| // that results in widgets being inflated in the wrong orientation. |
| private int mOrientation; |
| |
| private SpannableStringBuilder mDefaultKeySsb = null; |
| |
| @Thunk boolean mWorkspaceLoading = true; |
| |
| private boolean mPaused = true; |
| private boolean mOnResumeNeedsLoad; |
| |
| private final ArrayList<Runnable> mBindOnResumeCallbacks = new ArrayList<>(); |
| private OnResumeCallback mOnResumeCallback; |
| |
| private ViewOnDrawExecutor mPendingExecutor; |
| |
| private LauncherModel mModel; |
| private ModelWriter mModelWriter; |
| private IconCache mIconCache; |
| private LauncherAccessibilityDelegate mAccessibilityDelegate; |
| private boolean mHasFocus = false; |
| |
| private ObjectAnimator mScrimAnimator; |
| private boolean mShouldFadeInScrim; |
| |
| private PopupDataProvider mPopupDataProvider; |
| |
| private final ArrayList<Integer> mSynchronouslyBoundPages = new ArrayList<>(); |
| |
| // We only want to get the SharedPreferences once since it does an FS stat each time we get |
| // it from the context. |
| private SharedPreferences mSharedPrefs; |
| |
| // Activity result which needs to be processed after workspace has loaded. |
| private ActivityResultInfo mPendingActivityResult; |
| /** |
| * Holds extra information required to handle a result from an external call, like |
| * {@link #startActivityForResult(Intent, int)} or {@link #requestPermissions(String[], int)} |
| */ |
| private PendingRequestArgs mPendingRequestArgs; |
| |
| private float mLastDispatchTouchEventX = 0.0f; |
| |
| public ViewGroupFocusHelper mFocusHandler; |
| private boolean mRotationEnabled = false; |
| private boolean mAppLaunchSuccess; |
| |
| private RotationPrefChangeHandler mRotationPrefChangeHandler; |
| |
| @Override |
| protected void onCreate(Bundle savedInstanceState) { |
| if (DEBUG_STRICT_MODE) { |
| StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder() |
| .detectDiskReads() |
| .detectDiskWrites() |
| .detectNetwork() // or .detectAll() for all detectable problems |
| .penaltyLog() |
| .build()); |
| StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder() |
| .detectLeakedSqlLiteObjects() |
| .detectLeakedClosableObjects() |
| .penaltyLog() |
| .penaltyDeath() |
| .build()); |
| } |
| TraceHelper.beginSection("Launcher-onCreate"); |
| |
| if (mLauncherCallbacks != null) { |
| mLauncherCallbacks.preOnCreate(); |
| } |
| |
| WallpaperColorInfo wallpaperColorInfo = WallpaperColorInfo.getInstance(this); |
| wallpaperColorInfo.setOnThemeChangeListener(this); |
| overrideTheme(wallpaperColorInfo.isDark(), wallpaperColorInfo.supportsDarkText()); |
| |
| super.onCreate(savedInstanceState); |
| TraceHelper.partitionSection("Launcher-onCreate", "super call"); |
| |
| LauncherAppState app = LauncherAppState.getInstance(this); |
| |
| // Load configuration-specific DeviceProfile |
| mDeviceProfile = app.getInvariantDeviceProfile().getDeviceProfile(this); |
| if (isInMultiWindowModeCompat()) { |
| Display display = getWindowManager().getDefaultDisplay(); |
| Point mwSize = new Point(); |
| display.getSize(mwSize); |
| mDeviceProfile = mDeviceProfile.getMultiWindowProfile(this, mwSize); |
| } |
| |
| mOrientation = getResources().getConfiguration().orientation; |
| mSharedPrefs = Utilities.getPrefs(this); |
| mIsSafeModeEnabled = getPackageManager().isSafeMode(); |
| mModel = app.setLauncher(this); |
| mModelWriter = mModel.getWriter(mDeviceProfile.isVerticalBarLayout()); |
| mIconCache = app.getIconCache(); |
| mAccessibilityDelegate = new LauncherAccessibilityDelegate(this); |
| |
| mDragController = new DragController(this); |
| mAllAppsController = new AllAppsTransitionController(this); |
| mStateManager = new LauncherStateManager(this, mAllAppsController); |
| |
| mAppWidgetManager = AppWidgetManagerCompat.getInstance(this); |
| |
| mAppWidgetHost = new LauncherAppWidgetHost(this); |
| mAppWidgetHost.startListening(); |
| |
| // If we are getting an onCreate, we can actually preempt onResume and unset mPaused here, |
| // this also ensures that any synchronous binding below doesn't re-trigger another |
| // LauncherModel load. |
| mPaused = false; |
| |
| mLauncherView = LayoutInflater.from(this).inflate(R.layout.launcher, null); |
| |
| setupViews(); |
| mDeviceProfile.layout(this, false /* notifyListeners */); |
| |
| mPopupDataProvider = new PopupDataProvider(this); |
| |
| ((AccessibilityManager) getSystemService(ACCESSIBILITY_SERVICE)) |
| .addAccessibilityStateChangeListener(this); |
| |
| restoreState(savedInstanceState); |
| |
| // We only load the page synchronously if the user rotates (or triggers a |
| // configuration change) while launcher is in the foreground |
| int currentScreen = PagedView.INVALID_RESTORE_PAGE; |
| if (savedInstanceState != null) { |
| currentScreen = savedInstanceState.getInt(RUNTIME_STATE_CURRENT_SCREEN, currentScreen); |
| } |
| if (!mModel.startLoader(currentScreen)) { |
| // If we are not binding synchronously, show a fade in animation when |
| // the first page bind completes. |
| mDragLayer.setAlpha(0); |
| } else { |
| // Pages bound synchronously. |
| mWorkspace.setCurrentPage(currentScreen); |
| |
| setWorkspaceLoading(true); |
| } |
| |
| // For handling default keys |
| mDefaultKeySsb = new SpannableStringBuilder(); |
| Selection.setSelection(mDefaultKeySsb, 0); |
| |
| mRotationEnabled = getResources().getBoolean(R.bool.allow_rotation); |
| // In case we are on a device with locked rotation, we should look at preferences to check |
| // if the user has specifically allowed rotation. |
| if (!mRotationEnabled) { |
| mRotationEnabled = Utilities.isAllowRotationPrefEnabled(getApplicationContext()); |
| mRotationPrefChangeHandler = new RotationPrefChangeHandler(); |
| mSharedPrefs.registerOnSharedPreferenceChangeListener(mRotationPrefChangeHandler); |
| } |
| |
| if (PinItemDragListener.handleDragRequest(this, getIntent())) { |
| // Temporarily enable the rotation |
| mRotationEnabled = true; |
| } |
| |
| // On large interfaces, or on devices that a user has specifically enabled screen rotation, |
| // we want the screen to auto-rotate based on the current orientation |
| setRequestedOrientation(mRotationEnabled |
| ? SCREEN_ORIENTATION_UNSPECIFIED : SCREEN_ORIENTATION_NOSENSOR); |
| |
| setContentView(mLauncherView); |
| |
| // Listen for broadcasts |
| IntentFilter filter = new IntentFilter(); |
| filter.addAction(Intent.ACTION_SCREEN_OFF); |
| filter.addAction(Intent.ACTION_USER_PRESENT); // When the device wakes up + keyguard is gone |
| registerReceiver(mReceiver, filter); |
| mShouldFadeInScrim = true; |
| |
| getSystemUiController().updateUiState(SystemUiController.UI_STATE_BASE_WINDOW, |
| Themes.getAttrBoolean(this, R.attr.isWorkspaceDarkText)); |
| |
| if (mLauncherCallbacks != null) { |
| mLauncherCallbacks.onCreate(savedInstanceState); |
| } |
| |
| TraceHelper.endSection("Launcher-onCreate"); |
| } |
| |
| @Override |
| public void onThemeChanged() { |
| recreate(); |
| } |
| |
| public LauncherStateManager getStateManager() { |
| return mStateManager; |
| } |
| |
| protected void overrideTheme(boolean isDark, boolean supportsDarkText) { |
| if (isDark) { |
| setTheme(R.style.LauncherThemeDark); |
| } else if (supportsDarkText) { |
| setTheme(R.style.LauncherThemeDarkText); |
| } |
| } |
| |
| @Override |
| public <T extends View> T findViewById(int id) { |
| return mLauncherView.findViewById(id); |
| } |
| |
| @Override |
| public void onAppWidgetHostReset() { |
| if (mAppWidgetHost != null) { |
| mAppWidgetHost.startListening(); |
| } |
| } |
| |
| private LauncherCallbacks mLauncherCallbacks; |
| |
| public void onInsetsChanged(Rect insets) { |
| mDeviceProfile.updateInsets(insets); |
| mDeviceProfile.layout(this, true /* notifyListeners */); |
| } |
| |
| /** |
| * Call this after onCreate to set or clear overlay. |
| */ |
| public void setLauncherOverlay(LauncherOverlay overlay) { |
| if (overlay != null) { |
| overlay.setOverlayCallbacks(new LauncherOverlayCallbacksImpl()); |
| } |
| mWorkspace.setLauncherOverlay(overlay); |
| } |
| |
| public boolean setLauncherCallbacks(LauncherCallbacks callbacks) { |
| mLauncherCallbacks = callbacks; |
| return true; |
| } |
| |
| @Override |
| public void onLauncherProviderChanged() { |
| if (mLauncherCallbacks != null) { |
| mLauncherCallbacks.onLauncherProviderChange(); |
| } |
| } |
| |
| public boolean isDraggingEnabled() { |
| // We prevent dragging when we are loading the workspace as it is possible to pick up a view |
| // that is subsequently removed from the workspace in startBinding(). |
| return !isWorkspaceLoading(); |
| } |
| |
| public int getViewIdForItem(ItemInfo info) { |
| // aapt-generated IDs have the high byte nonzero; clamp to the range under that. |
| // This cast is safe as long as the id < 0x00FFFFFF |
| // Since we jail all the dynamically generated views, there should be no clashes |
| // with any other views. |
| return (int) info.id; |
| } |
| |
| public PopupDataProvider getPopupDataProvider() { |
| return mPopupDataProvider; |
| } |
| |
| /** |
| * Returns whether we should delay spring loaded mode -- for shortcuts and widgets that have |
| * a configuration step, this allows the proper animations to run after other transitions. |
| */ |
| private long completeAdd( |
| int requestCode, Intent intent, int appWidgetId, PendingRequestArgs info) { |
| long screenId = info.screenId; |
| if (info.container == LauncherSettings.Favorites.CONTAINER_DESKTOP) { |
| // When the screen id represents an actual screen (as opposed to a rank) we make sure |
| // that the drop page actually exists. |
| screenId = ensurePendingDropLayoutExists(info.screenId); |
| } |
| |
| switch (requestCode) { |
| case REQUEST_CREATE_SHORTCUT: |
| completeAddShortcut(intent, info.container, screenId, info.cellX, info.cellY, info); |
| break; |
| case REQUEST_CREATE_APPWIDGET: |
| completeAddAppWidget(appWidgetId, info, null, null); |
| break; |
| case REQUEST_RECONFIGURE_APPWIDGET: |
| completeRestoreAppWidget(appWidgetId, LauncherAppWidgetInfo.RESTORE_COMPLETED); |
| break; |
| case REQUEST_BIND_PENDING_APPWIDGET: { |
| int widgetId = appWidgetId; |
| LauncherAppWidgetInfo widgetInfo = |
| completeRestoreAppWidget(widgetId, LauncherAppWidgetInfo.FLAG_UI_NOT_READY); |
| if (widgetInfo != null) { |
| // Since the view was just bound, also launch the configure activity if needed |
| LauncherAppWidgetProviderInfo provider = mAppWidgetManager |
| .getLauncherAppWidgetInfo(widgetId); |
| if (provider != null) { |
| new WidgetAddFlowHandler(provider) |
| .startConfigActivity(this, widgetInfo, REQUEST_RECONFIGURE_APPWIDGET); |
| } |
| } |
| break; |
| } |
| } |
| |
| return screenId; |
| } |
| |
| private void handleActivityResult( |
| final int requestCode, final int resultCode, final Intent data) { |
| if (isWorkspaceLoading()) { |
| // process the result once the workspace has loaded. |
| mPendingActivityResult = new ActivityResultInfo(requestCode, resultCode, data); |
| return; |
| } |
| mPendingActivityResult = null; |
| |
| // Reset the startActivity waiting flag |
| final PendingRequestArgs requestArgs = mPendingRequestArgs; |
| setWaitingForResult(null); |
| if (requestArgs == null) { |
| return; |
| } |
| |
| final int pendingAddWidgetId = requestArgs.getWidgetId(); |
| |
| Runnable exitSpringLoaded = new Runnable() { |
| @Override |
| public void run() { |
| mStateManager.goToState(NORMAL, SPRING_LOADED_EXIT_DELAY); |
| } |
| }; |
| |
| if (requestCode == REQUEST_BIND_APPWIDGET) { |
| // This is called only if the user did not previously have permissions to bind widgets |
| final int appWidgetId = data != null ? |
| data.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1) : -1; |
| if (resultCode == RESULT_CANCELED) { |
| completeTwoStageWidgetDrop(RESULT_CANCELED, appWidgetId, requestArgs); |
| mWorkspace.removeExtraEmptyScreenDelayed(true, exitSpringLoaded, |
| ON_ACTIVITY_RESULT_ANIMATION_DELAY, false); |
| } else if (resultCode == RESULT_OK) { |
| addAppWidgetImpl( |
| appWidgetId, requestArgs, null, |
| requestArgs.getWidgetHandler(), |
| ON_ACTIVITY_RESULT_ANIMATION_DELAY); |
| } |
| return; |
| } else if (requestCode == REQUEST_PICK_WALLPAPER) { |
| if (resultCode == RESULT_OK && isInState(OVERVIEW)) { |
| // User could have free-scrolled between pages before picking a wallpaper; make sure |
| // we move to the closest one now. |
| mWorkspace.setCurrentPage(mWorkspace.getPageNearestToCenterOfScreen()); |
| mStateManager.goToState(NORMAL, false); |
| } |
| return; |
| } |
| |
| boolean isWidgetDrop = (requestCode == REQUEST_PICK_APPWIDGET || |
| requestCode == REQUEST_CREATE_APPWIDGET); |
| |
| // We have special handling for widgets |
| if (isWidgetDrop) { |
| final int appWidgetId; |
| int widgetId = data != null ? data.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1) |
| : -1; |
| if (widgetId < 0) { |
| appWidgetId = pendingAddWidgetId; |
| } else { |
| appWidgetId = widgetId; |
| } |
| |
| final int result; |
| if (appWidgetId < 0 || resultCode == RESULT_CANCELED) { |
| Log.e(TAG, "Error: appWidgetId (EXTRA_APPWIDGET_ID) was not " + |
| "returned from the widget configuration activity."); |
| result = RESULT_CANCELED; |
| completeTwoStageWidgetDrop(result, appWidgetId, requestArgs); |
| final Runnable onComplete = new Runnable() { |
| @Override |
| public void run() { |
| getStateManager().goToState(NORMAL); |
| } |
| }; |
| |
| mWorkspace.removeExtraEmptyScreenDelayed(true, onComplete, |
| ON_ACTIVITY_RESULT_ANIMATION_DELAY, false); |
| } else { |
| if (requestArgs.container == LauncherSettings.Favorites.CONTAINER_DESKTOP) { |
| // When the screen id represents an actual screen (as opposed to a rank) |
| // we make sure that the drop page actually exists. |
| requestArgs.screenId = |
| ensurePendingDropLayoutExists(requestArgs.screenId); |
| } |
| final CellLayout dropLayout = |
| mWorkspace.getScreenWithId(requestArgs.screenId); |
| |
| dropLayout.setDropPending(true); |
| final Runnable onComplete = new Runnable() { |
| @Override |
| public void run() { |
| completeTwoStageWidgetDrop(resultCode, appWidgetId, requestArgs); |
| dropLayout.setDropPending(false); |
| } |
| }; |
| mWorkspace.removeExtraEmptyScreenDelayed(true, onComplete, |
| ON_ACTIVITY_RESULT_ANIMATION_DELAY, false); |
| } |
| return; |
| } |
| |
| if (requestCode == REQUEST_RECONFIGURE_APPWIDGET |
| || requestCode == REQUEST_BIND_PENDING_APPWIDGET) { |
| if (resultCode == RESULT_OK) { |
| // Update the widget view. |
| completeAdd(requestCode, data, pendingAddWidgetId, requestArgs); |
| } |
| // Leave the widget in the pending state if the user canceled the configure. |
| return; |
| } |
| |
| if (requestCode == REQUEST_CREATE_SHORTCUT) { |
| // Handle custom shortcuts created using ACTION_CREATE_SHORTCUT. |
| if (resultCode == RESULT_OK && requestArgs.container != ItemInfo.NO_ID) { |
| completeAdd(requestCode, data, -1, requestArgs); |
| mWorkspace.removeExtraEmptyScreenDelayed(true, exitSpringLoaded, |
| ON_ACTIVITY_RESULT_ANIMATION_DELAY, false); |
| |
| } else if (resultCode == RESULT_CANCELED) { |
| mWorkspace.removeExtraEmptyScreenDelayed(true, exitSpringLoaded, |
| ON_ACTIVITY_RESULT_ANIMATION_DELAY, false); |
| } |
| } |
| mDragLayer.clearAnimatedView(); |
| } |
| |
| @Override |
| public void onActivityResult( |
| final int requestCode, final int resultCode, final Intent data) { |
| handleActivityResult(requestCode, resultCode, data); |
| if (mLauncherCallbacks != null) { |
| mLauncherCallbacks.onActivityResult(requestCode, resultCode, data); |
| } |
| } |
| |
| @Override |
| public void onRequestPermissionsResult(int requestCode, String[] permissions, |
| int[] grantResults) { |
| PendingRequestArgs pendingArgs = mPendingRequestArgs; |
| if (requestCode == REQUEST_PERMISSION_CALL_PHONE && pendingArgs != null |
| && pendingArgs.getRequestCode() == REQUEST_PERMISSION_CALL_PHONE) { |
| setWaitingForResult(null); |
| |
| View v = null; |
| CellLayout layout = getCellLayout(pendingArgs.container, pendingArgs.screenId); |
| if (layout != null) { |
| v = layout.getChildAt(pendingArgs.cellX, pendingArgs.cellY); |
| } |
| Intent intent = pendingArgs.getPendingIntent(); |
| |
| if (grantResults.length > 0 |
| && grantResults[0] == PackageManager.PERMISSION_GRANTED) { |
| startActivitySafely(v, intent, null); |
| } else { |
| // TODO: Show a snack bar with link to settings |
| Toast.makeText(this, getString(R.string.msg_no_phone_permission, |
| getString(R.string.derived_app_name)), Toast.LENGTH_SHORT).show(); |
| } |
| } |
| if (mLauncherCallbacks != null) { |
| mLauncherCallbacks.onRequestPermissionsResult(requestCode, permissions, |
| grantResults); |
| } |
| } |
| |
| /** |
| * Check to see if a given screen id exists. If not, create it at the end, return the new id. |
| * |
| * @param screenId the screen id to check |
| * @return the new screen, or screenId if it exists |
| */ |
| private long ensurePendingDropLayoutExists(long screenId) { |
| CellLayout dropLayout = mWorkspace.getScreenWithId(screenId); |
| if (dropLayout == null) { |
| // it's possible that the add screen was removed because it was |
| // empty and a re-bind occurred |
| mWorkspace.addExtraEmptyScreen(); |
| return mWorkspace.commitExtraEmptyScreen(); |
| } else { |
| return screenId; |
| } |
| } |
| |
| @Thunk void completeTwoStageWidgetDrop( |
| final int resultCode, final int appWidgetId, final PendingRequestArgs requestArgs) { |
| CellLayout cellLayout = mWorkspace.getScreenWithId(requestArgs.screenId); |
| Runnable onCompleteRunnable = null; |
| int animationType = 0; |
| |
| AppWidgetHostView boundWidget = null; |
| if (resultCode == RESULT_OK) { |
| animationType = Workspace.COMPLETE_TWO_STAGE_WIDGET_DROP_ANIMATION; |
| final AppWidgetHostView layout = mAppWidgetHost.createView(this, appWidgetId, |
| requestArgs.getWidgetHandler().getProviderInfo(this)); |
| boundWidget = layout; |
| onCompleteRunnable = new Runnable() { |
| @Override |
| public void run() { |
| completeAddAppWidget(appWidgetId, requestArgs, layout, null); |
| mStateManager.goToState(NORMAL, SPRING_LOADED_EXIT_DELAY); |
| } |
| }; |
| } else if (resultCode == RESULT_CANCELED) { |
| mAppWidgetHost.deleteAppWidgetId(appWidgetId); |
| animationType = Workspace.CANCEL_TWO_STAGE_WIDGET_DROP_ANIMATION; |
| } |
| if (mDragLayer.getAnimatedView() != null) { |
| mWorkspace.animateWidgetDrop(requestArgs, cellLayout, |
| (DragView) mDragLayer.getAnimatedView(), onCompleteRunnable, |
| animationType, boundWidget, true); |
| } else if (onCompleteRunnable != null) { |
| // The animated view may be null in the case of a rotation during widget configuration |
| onCompleteRunnable.run(); |
| } |
| } |
| |
| @Override |
| protected void onStop() { |
| super.onStop(); |
| FirstFrameAnimatorHelper.setIsVisible(false); |
| |
| if (mLauncherCallbacks != null) { |
| mLauncherCallbacks.onStop(); |
| } |
| |
| if (Utilities.ATLEAST_NOUGAT_MR1) { |
| mAppWidgetHost.stopListening(); |
| } |
| |
| if (!mAppLaunchSuccess) { |
| getUserEventDispatcher().logActionCommand(Action.Command.STOP, |
| mStateManager.getState().containerType); |
| } |
| NotificationListener.removeNotificationsChangedListener(); |
| } |
| |
| @Override |
| protected void onStart() { |
| super.onStart(); |
| FirstFrameAnimatorHelper.setIsVisible(true); |
| |
| if (mLauncherCallbacks != null) { |
| mLauncherCallbacks.onStart(); |
| } |
| |
| if (Utilities.ATLEAST_NOUGAT_MR1) { |
| mAppWidgetHost.startListening(); |
| } |
| |
| if (!isWorkspaceLoading()) { |
| NotificationListener.setNotificationsChangedListener(mPopupDataProvider); |
| } |
| |
| if (mShouldFadeInScrim && mDragLayer.getBackground() != null) { |
| if (mScrimAnimator != null) { |
| mScrimAnimator.cancel(); |
| } |
| mDragLayer.getBackground().setAlpha(0); |
| mScrimAnimator = ObjectAnimator.ofInt(mDragLayer.getBackground(), |
| LauncherAnimUtils.DRAWABLE_ALPHA, 0, 255); |
| mScrimAnimator.addListener(new AnimatorListenerAdapter() { |
| @Override |
| public void onAnimationEnd(Animator animation) { |
| mScrimAnimator = null; |
| } |
| }); |
| mScrimAnimator.setDuration(600); |
| mScrimAnimator.setStartDelay(getWindow().getTransitionBackgroundFadeDuration()); |
| mScrimAnimator.start(); |
| } |
| mShouldFadeInScrim = false; |
| } |
| |
| @Override |
| protected void onResume() { |
| TraceHelper.beginSection("ON_RESUME"); |
| super.onResume(); |
| TraceHelper.partitionSection("ON_RESUME", "superCall"); |
| |
| mAppLaunchSuccess = false; |
| getUserEventDispatcher().resetElapsedSessionMillis(); |
| mPaused = false; |
| if (mOnResumeNeedsLoad) { |
| setWorkspaceLoading(true); |
| mModel.startLoader(getCurrentWorkspaceScreen()); |
| mOnResumeNeedsLoad = false; |
| } |
| if (mBindOnResumeCallbacks.size() > 0) { |
| // We might have postponed some bind calls until onResume (see waitUntilResume) -- |
| // execute them here |
| for (int i = 0; i < mBindOnResumeCallbacks.size(); i++) { |
| mBindOnResumeCallbacks.get(i).run(); |
| } |
| mBindOnResumeCallbacks.clear(); |
| } |
| |
| setOnResumeCallback(null); |
| // Process any items that were added while Launcher was away. |
| InstallShortcutReceiver.disableAndFlushInstallQueue( |
| InstallShortcutReceiver.FLAG_ACTIVITY_PAUSED, this); |
| |
| // Refresh shortcuts if the permission changed. |
| mModel.refreshShortcutsIfRequired(); |
| |
| if (shouldShowDiscoveryBounce()) { |
| mAllAppsController.showDiscoveryBounce(); |
| } |
| if (mLauncherCallbacks != null) { |
| mLauncherCallbacks.onResume(); |
| } |
| |
| clearTypedText(); |
| |
| TraceHelper.endSection("ON_RESUME"); |
| } |
| |
| @Override |
| protected void onPause() { |
| // Ensure that items added to Launcher are queued until Launcher returns |
| InstallShortcutReceiver.enableInstallQueue(InstallShortcutReceiver.FLAG_ACTIVITY_PAUSED); |
| |
| super.onPause(); |
| mPaused = true; |
| mDragController.cancelDrag(); |
| mDragController.resetLastGestureUpTime(); |
| |
| if (mLauncherCallbacks != null) { |
| mLauncherCallbacks.onPause(); |
| } |
| } |
| |
| public interface LauncherOverlay { |
| |
| /** |
| * Touch interaction leading to overscroll has begun |
| */ |
| void onScrollInteractionBegin(); |
| |
| /** |
| * Touch interaction related to overscroll has ended |
| */ |
| void onScrollInteractionEnd(); |
| |
| /** |
| * Scroll progress, between 0 and 100, when the user scrolls beyond the leftmost |
| * screen (or in the case of RTL, the rightmost screen). |
| */ |
| void onScrollChange(float progress, boolean rtl); |
| |
| /** |
| * Called when the launcher is ready to use the overlay |
| * @param callbacks A set of callbacks provided by Launcher in relation to the overlay |
| */ |
| void setOverlayCallbacks(LauncherOverlayCallbacks callbacks); |
| } |
| |
| public interface LauncherOverlayCallbacks { |
| void onScrollChanged(float progress); |
| } |
| |
| class LauncherOverlayCallbacksImpl implements LauncherOverlayCallbacks { |
| |
| public void onScrollChanged(float progress) { |
| if (mWorkspace != null) { |
| mWorkspace.onOverlayScrollChanged(progress); |
| } |
| } |
| } |
| |
| protected boolean hasSettings() { |
| if (mLauncherCallbacks != null) { |
| return mLauncherCallbacks.hasSettings(); |
| } else { |
| // On O and above we there is always some setting present settings (add icon to |
| // home screen or icon badging). On earlier APIs we will have the allow rotation |
| // setting, on devices with a locked orientation, |
| return Utilities.ATLEAST_OREO || !getResources().getBoolean(R.bool.allow_rotation); |
| } |
| } |
| |
| @Override |
| public Object onRetainNonConfigurationInstance() { |
| // Flag the loader to stop early before switching |
| if (mModel.isCurrentCallbacks(this)) { |
| mModel.stopLoader(); |
| } |
| //TODO(hyunyoungs): stop the widgets loader when there is a rotation. |
| |
| return Boolean.TRUE; |
| } |
| |
| // We can't hide the IME if it was forced open. So don't bother |
| @Override |
| public void onWindowFocusChanged(boolean hasFocus) { |
| super.onWindowFocusChanged(hasFocus); |
| mHasFocus = hasFocus; |
| |
| if (mLauncherCallbacks != null) { |
| mLauncherCallbacks.onWindowFocusChanged(hasFocus); |
| } |
| } |
| |
| private boolean acceptFilter() { |
| final InputMethodManager inputManager = (InputMethodManager) |
| getSystemService(Context.INPUT_METHOD_SERVICE); |
| return !inputManager.isFullscreenMode(); |
| } |
| |
| @Override |
| public boolean onKeyDown(int keyCode, KeyEvent event) { |
| final int uniChar = event.getUnicodeChar(); |
| final boolean handled = super.onKeyDown(keyCode, event); |
| final boolean isKeyNotWhitespace = uniChar > 0 && !Character.isWhitespace(uniChar); |
| if (!handled && acceptFilter() && isKeyNotWhitespace) { |
| boolean gotKey = TextKeyListener.getInstance().onKeyDown(mWorkspace, mDefaultKeySsb, |
| keyCode, event); |
| if (gotKey && mDefaultKeySsb != null && mDefaultKeySsb.length() > 0) { |
| // something usable has been typed - start a search |
| // the typed text will be retrieved and cleared by |
| // showSearchDialog() |
| // If there are multiple keystrokes before the search dialog takes focus, |
| // onSearchRequested() will be called for every keystroke, |
| // but it is idempotent, so it's fine. |
| return onSearchRequested(); |
| } |
| } |
| |
| // Eat the long press event so the keyboard doesn't come up. |
| if (keyCode == KeyEvent.KEYCODE_MENU && event.isLongPress()) { |
| return true; |
| } |
| |
| return handled; |
| } |
| |
| @Override |
| public boolean onKeyUp(int keyCode, KeyEvent event) { |
| if (keyCode == KeyEvent.KEYCODE_MENU) { |
| // Ignore the menu key if we are currently dragging or are on the custom content screen |
| if (!mDragController.isDragging()) { |
| // Close any open floating view |
| AbstractFloatingView.closeAllOpenViews(this); |
| |
| // Show the overview mode if we are on the workspace |
| if (isInState(NORMAL) && !mWorkspace.isSwitchingState()) { |
| mStateManager.goToState(OVERVIEW, true /* animate */, new Runnable() { |
| @Override |
| public void run() { |
| // Hitting the menu button when in touch mode does not trigger touch |
| // mode to be disabled, so if requested, force focus on one of the |
| // overview panel buttons. |
| mOverviewPanel.requestFocusFromTouch(); |
| } |
| }); |
| } |
| } |
| return true; |
| } |
| return super.onKeyUp(keyCode, event); |
| } |
| |
| private String getTypedText() { |
| return mDefaultKeySsb.toString(); |
| } |
| |
| @Override |
| public void clearTypedText() { |
| mDefaultKeySsb.clear(); |
| mDefaultKeySsb.clearSpans(); |
| Selection.setSelection(mDefaultKeySsb, 0); |
| } |
| |
| public boolean isInState(LauncherState state) { |
| return mStateManager.getState() == state; |
| } |
| |
| /** |
| * Restores the previous state, if it exists. |
| * |
| * @param savedState The previous state. |
| */ |
| private void restoreState(Bundle savedState) { |
| if (savedState == null) { |
| return; |
| } |
| |
| int stateOrdinal = savedState.getInt(RUNTIME_STATE, NORMAL.ordinal); |
| LauncherState[] stateValues = LauncherState.values(); |
| LauncherState state = stateValues[stateOrdinal]; |
| if (!state.doNotRestore) { |
| mStateManager.goToState(state, false /* animated */); |
| } |
| |
| PendingRequestArgs requestArgs = savedState.getParcelable(RUNTIME_STATE_PENDING_REQUEST_ARGS); |
| if (requestArgs != null) { |
| setWaitingForResult(requestArgs); |
| } |
| |
| mPendingActivityResult = savedState.getParcelable(RUNTIME_STATE_PENDING_ACTIVITY_RESULT); |
| |
| SparseArray<Parcelable> widgetsState = |
| savedState.getSparseParcelableArray(RUNTIME_STATE_WIDGET_PANEL); |
| if (widgetsState != null) { |
| WidgetsFullSheet.show(this, false).restoreHierarchyState(widgetsState); |
| } |
| } |
| |
| /** |
| * Finds all the views we need and configure them properly. |
| */ |
| private void setupViews() { |
| mDragLayer = (DragLayer) findViewById(R.id.drag_layer); |
| mFocusHandler = mDragLayer.getFocusIndicatorHelper(); |
| mWorkspace = mDragLayer.findViewById(R.id.workspace); |
| mWorkspace.initParentViews(mDragLayer); |
| |
| mLauncherView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN |
| | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION |
| | View.SYSTEM_UI_FLAG_LAYOUT_STABLE); |
| |
| // Setup the drag layer |
| mDragLayer.setup(this, mDragController, mAllAppsController); |
| |
| // Setup the hotseat |
| mHotseat = (Hotseat) findViewById(R.id.hotseat); |
| if (mHotseat != null) { |
| mHotseat.setOnLongClickListener(this); |
| } |
| |
| // Setup the overview panel |
| setupOverviewPanel(); |
| |
| // Setup the workspace |
| mWorkspace.setHapticFeedbackEnabled(false); |
| mWorkspace.setOnLongClickListener(this); |
| mWorkspace.setup(mDragController); |
| // Until the workspace is bound, ensure that we keep the wallpaper offset locked to the |
| // default state, otherwise we will update to the wrong offsets in RTL |
| mWorkspace.lockWallpaperToDefaultPage(); |
| mWorkspace.bindAndInitFirstWorkspaceScreen(null /* recycled qsb */); |
| mDragController.addDragListener(mWorkspace); |
| |
| // Get the search/delete/uninstall bar |
| mDropTargetBar = mDragLayer.findViewById(R.id.drop_target_bar); |
| |
| // Setup Apps |
| mAppsView = findViewById(R.id.apps_view); |
| |
| // Setup the drag controller (drop targets have to be added in reverse order in priority) |
| mDragController.setMoveTarget(mWorkspace); |
| mDragController.addDropTarget(mWorkspace); |
| mDropTargetBar.setup(mDragController); |
| |
| mAllAppsController.setupViews(mAppsView, mHotseat, mWorkspace); |
| |
| if (TestingUtils.MEMORY_DUMP_ENABLED) { |
| TestingUtils.addWeightWatcher(this); |
| } |
| } |
| |
| private void setupOverviewPanel() { |
| mOverviewPanel = findViewById(R.id.overview_panel); |
| |
| // Bind wallpaper button actions |
| View wallpaperButton = findViewById(R.id.wallpaper_button); |
| new OverviewButtonClickListener(ControlType.WALLPAPER_BUTTON) { |
| @Override |
| public void handleViewClick(View view) { |
| onClickWallpaperPicker(view); |
| } |
| }.attachTo(wallpaperButton); |
| |
| // Bind widget button actions |
| new OverviewButtonClickListener(ControlType.WIDGETS_BUTTON) { |
| @Override |
| public void handleViewClick(View view) { |
| onClickAddWidgetButton(view); |
| } |
| }.attachTo(findViewById(R.id.widget_button)); |
| |
| // Bind settings actions |
| View settingsButton = findViewById(R.id.settings_button); |
| boolean hasSettings = hasSettings(); |
| if (hasSettings) { |
| new OverviewButtonClickListener(ControlType.SETTINGS_BUTTON) { |
| @Override |
| public void handleViewClick(View view) { |
| onClickSettingsButton(view); |
| } |
| }.attachTo(settingsButton); |
| } else { |
| settingsButton.setVisibility(View.GONE); |
| } |
| |
| mOverviewPanel.setAlpha(0f); |
| } |
| |
| /** |
| * Sets the all apps button. This method is called from {@link Hotseat}. |
| * TODO: Get rid of this. |
| */ |
| public void setAllAppsButton(View allAppsButton) { |
| mAllAppsButton = allAppsButton; |
| } |
| |
| /** |
| * Creates a view representing a shortcut. |
| * |
| * @param info The data structure describing the shortcut. |
| */ |
| View createShortcut(ShortcutInfo info) { |
| return createShortcut((ViewGroup) mWorkspace.getChildAt(mWorkspace.getCurrentPage()), info); |
| } |
| |
| /** |
| * Creates a view representing a shortcut inflated from the specified resource. |
| * |
| * @param parent The group the shortcut belongs to. |
| * @param info The data structure describing the shortcut. |
| * |
| * @return A View inflated from layoutResId. |
| */ |
| public View createShortcut(ViewGroup parent, ShortcutInfo info) { |
| BubbleTextView favorite = (BubbleTextView) LayoutInflater.from(parent.getContext()) |
| .inflate(R.layout.app_icon, parent, false); |
| favorite.applyFromShortcutInfo(info); |
| favorite.setOnClickListener(this); |
| favorite.setOnFocusChangeListener(mFocusHandler); |
| return favorite; |
| } |
| |
| /** |
| * Add a shortcut to the workspace or to a Folder. |
| * |
| * @param data The intent describing the shortcut. |
| */ |
| private void completeAddShortcut(Intent data, long container, long screenId, int cellX, |
| int cellY, PendingRequestArgs args) { |
| if (args.getRequestCode() != REQUEST_CREATE_SHORTCUT |
| || args.getPendingIntent().getComponent() == null) { |
| return; |
| } |
| |
| int[] cellXY = mTmpAddItemCellCoordinates; |
| CellLayout layout = getCellLayout(container, screenId); |
| |
| ShortcutInfo info = null; |
| if (Utilities.ATLEAST_OREO) { |
| info = LauncherAppsCompatVO.createShortcutInfoFromPinItemRequest( |
| this, LauncherAppsCompatVO.getPinItemRequest(data), 0); |
| } |
| |
| if (info == null) { |
| // Legacy shortcuts are only supported for primary profile. |
| info = Process.myUserHandle().equals(args.user) |
| ? InstallShortcutReceiver.fromShortcutIntent(this, data) : null; |
| |
| if (info == null) { |
| Log.e(TAG, "Unable to parse a valid custom shortcut result"); |
| return; |
| } else if (!new PackageManagerHelper(this).hasPermissionForActivity( |
| info.intent, args.getPendingIntent().getComponent().getPackageName())) { |
| // The app is trying to add a shortcut without sufficient permissions |
| Log.e(TAG, "Ignoring malicious intent " + info.intent.toUri(0)); |
| return; |
| } |
| } |
| |
| if (container < 0) { |
| // Adding a shortcut to the Workspace. |
| final View view = createShortcut(info); |
| boolean foundCellSpan = false; |
| // First we check if we already know the exact location where we want to add this item. |
| if (cellX >= 0 && cellY >= 0) { |
| cellXY[0] = cellX; |
| cellXY[1] = cellY; |
| foundCellSpan = true; |
| |
| // If appropriate, either create a folder or add to an existing folder |
| if (mWorkspace.createUserFolderIfNecessary(view, container, layout, cellXY, 0, |
| true, null)) { |
| return; |
| } |
| DragObject dragObject = new DragObject(); |
| dragObject.dragInfo = info; |
| if (mWorkspace.addToExistingFolderIfNecessary(view, layout, cellXY, 0, dragObject, |
| true)) { |
| return; |
| } |
| } else { |
| foundCellSpan = layout.findCellForSpan(cellXY, 1, 1); |
| } |
| |
| if (!foundCellSpan) { |
| mWorkspace.onNoCellFound(layout); |
| return; |
| } |
| |
| getModelWriter().addItemToDatabase(info, container, screenId, cellXY[0], cellXY[1]); |
| mWorkspace.addInScreen(view, info); |
| } else { |
| // Adding a shortcut to a Folder. |
| FolderIcon folderIcon = findFolderIcon(container); |
| if (folderIcon != null) { |
| FolderInfo folderInfo = (FolderInfo) folderIcon.getTag(); |
| folderInfo.add(info, args.rank, false); |
| } else { |
| Log.e(TAG, "Could not find folder with id " + container + " to add shortcut."); |
| } |
| } |
| } |
| |
| public FolderIcon findFolderIcon(final long folderIconId) { |
| return (FolderIcon) mWorkspace.getFirstMatch(new ItemOperator() { |
| @Override |
| public boolean evaluate(ItemInfo info, View view) { |
| return info != null && info.id == folderIconId; |
| } |
| }); |
| } |
| |
| /** |
| * Add a widget to the workspace. |
| * |
| * @param appWidgetId The app widget id |
| */ |
| @Thunk void completeAddAppWidget(int appWidgetId, ItemInfo itemInfo, |
| AppWidgetHostView hostView, LauncherAppWidgetProviderInfo appWidgetInfo) { |
| |
| if (appWidgetInfo == null) { |
| appWidgetInfo = mAppWidgetManager.getLauncherAppWidgetInfo(appWidgetId); |
| } |
| |
| LauncherAppWidgetInfo launcherInfo; |
| launcherInfo = new LauncherAppWidgetInfo(appWidgetId, appWidgetInfo.provider); |
| launcherInfo.spanX = itemInfo.spanX; |
| launcherInfo.spanY = itemInfo.spanY; |
| launcherInfo.minSpanX = itemInfo.minSpanX; |
| launcherInfo.minSpanY = itemInfo.minSpanY; |
| launcherInfo.user = appWidgetInfo.getProfile(); |
| |
| getModelWriter().addItemToDatabase(launcherInfo, |
| itemInfo.container, itemInfo.screenId, itemInfo.cellX, itemInfo.cellY); |
| |
| if (hostView == null) { |
| // Perform actual inflation because we're live |
| hostView = mAppWidgetHost.createView(this, appWidgetId, appWidgetInfo); |
| } |
| hostView.setVisibility(View.VISIBLE); |
| prepareAppWidget(hostView, launcherInfo); |
| mWorkspace.addInScreen(hostView, launcherInfo); |
| } |
| |
| private void prepareAppWidget(AppWidgetHostView hostView, LauncherAppWidgetInfo item) { |
| hostView.setTag(item); |
| item.onBindAppWidget(this, hostView); |
| hostView.setFocusable(true); |
| hostView.setOnFocusChangeListener(mFocusHandler); |
| } |
| |
| private final BroadcastReceiver mReceiver = new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| final String action = intent.getAction(); |
| if (Intent.ACTION_SCREEN_OFF.equals(action)) { |
| // Reset AllApps to its initial state only if we are not in the middle of |
| // processing a multi-step drop |
| if (mAppsView != null && mPendingRequestArgs == null) { |
| mStateManager.goToState(NORMAL); |
| } |
| mShouldFadeInScrim = true; |
| } else if (Intent.ACTION_USER_PRESENT.equals(action)) { |
| // ACTION_USER_PRESENT is sent after onStart/onResume. This covers the case where |
| // the user unlocked and the Launcher is not in the foreground. |
| mShouldFadeInScrim = false; |
| } |
| } |
| }; |
| |
| public void updateIconBadges(final Set<PackageUserKey> updatedBadges) { |
| Runnable r = new Runnable() { |
| @Override |
| public void run() { |
| mWorkspace.updateIconBadges(updatedBadges); |
| mAppsView.updateIconBadges(updatedBadges); |
| |
| BaseActionPopup popup = BaseActionPopup.getOpen(Launcher.this); |
| if (popup instanceof PopupContainerWithArrow) { |
| ((PopupContainerWithArrow) popup).updateNotificationHeader(updatedBadges); |
| } |
| } |
| }; |
| if (!waitUntilResume(r)) { |
| r.run(); |
| } |
| } |
| |
| @Override |
| public void onAttachedToWindow() { |
| super.onAttachedToWindow(); |
| |
| FirstFrameAnimatorHelper.initializeDrawListener(getWindow().getDecorView()); |
| if (mLauncherCallbacks != null) { |
| mLauncherCallbacks.onAttachedToWindow(); |
| } |
| } |
| |
| @Override |
| public void onDetachedFromWindow() { |
| super.onDetachedFromWindow(); |
| |
| if (mLauncherCallbacks != null) { |
| mLauncherCallbacks.onDetachedFromWindow(); |
| } |
| } |
| |
| public DragLayer getDragLayer() { |
| return mDragLayer; |
| } |
| |
| public AllAppsContainerView getAppsView() { |
| return mAppsView; |
| } |
| |
| public Workspace getWorkspace() { |
| return mWorkspace; |
| } |
| |
| public Hotseat getHotseat() { |
| return mHotseat; |
| } |
| |
| public ViewGroup getOverviewPanel() { |
| return mOverviewPanel; |
| } |
| |
| public DropTargetBar getDropTargetBar() { |
| return mDropTargetBar; |
| } |
| |
| public LauncherAppWidgetHost getAppWidgetHost() { |
| return mAppWidgetHost; |
| } |
| |
| public LauncherModel getModel() { |
| return mModel; |
| } |
| |
| public ModelWriter getModelWriter() { |
| return mModelWriter; |
| } |
| |
| public SharedPreferences getSharedPrefs() { |
| return mSharedPrefs; |
| } |
| |
| public int getOrientation() { return mOrientation; } |
| |
| @Override |
| protected void onNewIntent(Intent intent) { |
| TraceHelper.beginSection("NEW_INTENT"); |
| super.onNewIntent(intent); |
| |
| boolean alreadyOnHome = mHasFocus && ((intent.getFlags() & |
| Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT) |
| != Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT); |
| |
| // Check this condition before handling isActionMain, as this will get reset. |
| boolean shouldMoveToDefaultScreen = alreadyOnHome && isInState(NORMAL) |
| && AbstractFloatingView.getTopOpenView(this) == null; |
| |
| boolean isActionMain = Intent.ACTION_MAIN.equals(intent.getAction()); |
| if (isActionMain) { |
| if (mWorkspace == null) { |
| // Can be cases where mWorkspace is null, this prevents a NPE |
| return; |
| } |
| |
| // Note: There should be at most one log per method call. This is enforced implicitly |
| // by using if-else statements. |
| UserEventDispatcher ued = getUserEventDispatcher(); |
| AbstractFloatingView topOpenView = AbstractFloatingView.getTopOpenView(this); |
| if (topOpenView != null) { |
| topOpenView.logActionCommand(Action.Command.HOME_INTENT); |
| } else if (alreadyOnHome) { |
| Target target = newContainerTarget(mStateManager.getState().containerType); |
| target.pageIndex = mWorkspace.getCurrentPage(); |
| ued.logActionCommand(Action.Command.HOME_INTENT, target); |
| } |
| |
| // In all these cases, only animate if we're already on home |
| AbstractFloatingView.closeAllOpenViews(this, alreadyOnHome); |
| mStateManager.goToState(NORMAL, alreadyOnHome /* animated */); |
| |
| final View v = getWindow().peekDecorView(); |
| if (v != null && v.getWindowToken() != null) { |
| UiThreadHelper.hideKeyboardAsync(this, v.getWindowToken()); |
| } |
| |
| // Reset the apps view |
| if (!alreadyOnHome && mAppsView != null) { |
| mAppsView.reset(); |
| } |
| |
| if (mLauncherCallbacks != null) { |
| mLauncherCallbacks.onHomeIntent(); |
| } |
| } |
| PinItemDragListener.handleDragRequest(this, intent); |
| |
| if (mLauncherCallbacks != null) { |
| mLauncherCallbacks.onNewIntent(intent); |
| } |
| |
| // Defer moving to the default screen until after we callback to the LauncherCallbacks |
| // as slow logic in the callbacks eat into the time the scroller expects for the snapToPage |
| // animation. |
| if (isActionMain) { |
| if (shouldMoveToDefaultScreen && !mWorkspace.isTouchActive()) { |
| |
| mWorkspace.post(new Runnable() { |
| @Override |
| public void run() { |
| if (mWorkspace != null) { |
| mWorkspace.moveToDefaultScreen(); |
| } |
| } |
| }); |
| } |
| } |
| |
| TraceHelper.endSection("NEW_INTENT"); |
| } |
| |
| @Override |
| public void onRestoreInstanceState(Bundle state) { |
| super.onRestoreInstanceState(state); |
| for (int page: mSynchronouslyBoundPages) { |
| mWorkspace.restoreInstanceStateForChild(page); |
| } |
| } |
| |
| @Override |
| protected void onSaveInstanceState(Bundle outState) { |
| if (mWorkspace.getChildCount() > 0) { |
| outState.putInt(RUNTIME_STATE_CURRENT_SCREEN, mWorkspace.getNextPage()); |
| |
| } |
| outState.putInt(RUNTIME_STATE, mStateManager.getState().ordinal); |
| |
| |
| AbstractFloatingView widgets = AbstractFloatingView |
| .getOpenView(this, AbstractFloatingView.TYPE_WIDGETS_FULL_SHEET); |
| if (widgets != null) { |
| SparseArray<Parcelable> widgetsState = new SparseArray<>(); |
| widgets.saveHierarchyState(widgetsState); |
| outState.putSparseParcelableArray(RUNTIME_STATE_WIDGET_PANEL, widgetsState); |
| } else { |
| outState.remove(RUNTIME_STATE_WIDGET_PANEL); |
| } |
| |
| // We close any open folders and shortcut containers since they will not be re-opened, |
| // and we need to make sure this state is reflected. |
| AbstractFloatingView.closeAllOpenViews(this, false); |
| |
| if (mPendingRequestArgs != null) { |
| outState.putParcelable(RUNTIME_STATE_PENDING_REQUEST_ARGS, mPendingRequestArgs); |
| } |
| if (mPendingActivityResult != null) { |
| outState.putParcelable(RUNTIME_STATE_PENDING_ACTIVITY_RESULT, mPendingActivityResult); |
| } |
| |
| super.onSaveInstanceState(outState); |
| |
| if (mLauncherCallbacks != null) { |
| mLauncherCallbacks.onSaveInstanceState(outState); |
| } |
| } |
| |
| @Override |
| public void onDestroy() { |
| super.onDestroy(); |
| |
| unregisterReceiver(mReceiver); |
| mWorkspace.removeFolderListeners(); |
| |
| // Stop callbacks from LauncherModel |
| // It's possible to receive onDestroy after a new Launcher activity has |
| // been created. In this case, don't interfere with the new Launcher. |
| if (mModel.isCurrentCallbacks(this)) { |
| mModel.stopLoader(); |
| LauncherAppState.getInstance(this).setLauncher(null); |
| } |
| |
| if (mRotationPrefChangeHandler != null) { |
| mSharedPrefs.unregisterOnSharedPreferenceChangeListener(mRotationPrefChangeHandler); |
| } |
| |
| try { |
| mAppWidgetHost.stopListening(); |
| } catch (NullPointerException ex) { |
| Log.w(TAG, "problem while stopping AppWidgetHost during Launcher destruction", ex); |
| } |
| mAppWidgetHost = null; |
| |
| TextKeyListener.getInstance().release(); |
| |
| ((AccessibilityManager) getSystemService(ACCESSIBILITY_SERVICE)) |
| .removeAccessibilityStateChangeListener(this); |
| |
| WallpaperColorInfo.getInstance(this).setOnThemeChangeListener(null); |
| |
| LauncherAnimUtils.onDestroyActivity(); |
| |
| clearPendingBinds(); |
| |
| if (mLauncherCallbacks != null) { |
| mLauncherCallbacks.onDestroy(); |
| } |
| } |
| |
| public LauncherAccessibilityDelegate getAccessibilityDelegate() { |
| return mAccessibilityDelegate; |
| } |
| |
| public DragController getDragController() { |
| return mDragController; |
| } |
| |
| @Override |
| public void startActivityForResult(Intent intent, int requestCode, Bundle options) { |
| super.startActivityForResult(intent, requestCode, options); |
| } |
| |
| @Override |
| public void startIntentSenderForResult (IntentSender intent, int requestCode, |
| Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags, Bundle options) { |
| try { |
| super.startIntentSenderForResult(intent, requestCode, |
| fillInIntent, flagsMask, flagsValues, extraFlags, options); |
| } catch (IntentSender.SendIntentException e) { |
| throw new ActivityNotFoundException(); |
| } |
| } |
| |
| /** |
| * Indicates that we want global search for this activity by setting the globalSearch |
| * argument for {@link #startSearch} to true. |
| */ |
| @Override |
| public void startSearch(String initialQuery, boolean selectInitialQuery, |
| Bundle appSearchData, boolean globalSearch) { |
| |
| if (initialQuery == null) { |
| // Use any text typed in the launcher as the initial query |
| initialQuery = getTypedText(); |
| } |
| if (appSearchData == null) { |
| appSearchData = new Bundle(); |
| appSearchData.putString("source", "launcher-search"); |
| } |
| |
| if (mLauncherCallbacks == null || |
| !mLauncherCallbacks.startSearch(initialQuery, selectInitialQuery, appSearchData)) { |
| // Starting search from the callbacks failed. Start the default global search. |
| startGlobalSearch(initialQuery, selectInitialQuery, appSearchData, null); |
| } |
| |
| // We need to show the workspace after starting the search |
| mStateManager.goToState(NORMAL); |
| } |
| |
| /** |
| * Starts the global search activity. This code is a copied from SearchManager |
| */ |
| public void startGlobalSearch(String initialQuery, |
| boolean selectInitialQuery, Bundle appSearchData, Rect sourceBounds) { |
| final SearchManager searchManager = |
| (SearchManager) getSystemService(Context.SEARCH_SERVICE); |
| ComponentName globalSearchActivity = searchManager.getGlobalSearchActivity(); |
| if (globalSearchActivity == null) { |
| Log.w(TAG, "No global search activity found."); |
| return; |
| } |
| Intent intent = new Intent(SearchManager.INTENT_ACTION_GLOBAL_SEARCH); |
| intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); |
| intent.setComponent(globalSearchActivity); |
| // Make sure that we have a Bundle to put source in |
| if (appSearchData == null) { |
| appSearchData = new Bundle(); |
| } else { |
| appSearchData = new Bundle(appSearchData); |
| } |
| // Set source to package name of app that starts global search if not set already. |
| if (!appSearchData.containsKey("source")) { |
| appSearchData.putString("source", getPackageName()); |
| } |
| intent.putExtra(SearchManager.APP_DATA, appSearchData); |
| if (!TextUtils.isEmpty(initialQuery)) { |
| intent.putExtra(SearchManager.QUERY, initialQuery); |
| } |
| if (selectInitialQuery) { |
| intent.putExtra(SearchManager.EXTRA_SELECT_QUERY, selectInitialQuery); |
| } |
| intent.setSourceBounds(sourceBounds); |
| try { |
| startActivity(intent); |
| } catch (ActivityNotFoundException ex) { |
| Log.e(TAG, "Global search activity not found: " + globalSearchActivity); |
| } |
| } |
| |
| @Override |
| public boolean onPrepareOptionsMenu(Menu menu) { |
| super.onPrepareOptionsMenu(menu); |
| if (mLauncherCallbacks != null) { |
| return mLauncherCallbacks.onPrepareOptionsMenu(menu); |
| } |
| return false; |
| } |
| |
| @Override |
| public boolean onSearchRequested() { |
| startSearch(null, false, null, true); |
| // Use a custom animation for launching search |
| return true; |
| } |
| |
| public boolean isWorkspaceLocked() { |
| return mWorkspaceLoading || mPendingRequestArgs != null; |
| } |
| |
| public boolean isWorkspaceLoading() { |
| return mWorkspaceLoading; |
| } |
| |
| private void setWorkspaceLoading(boolean value) { |
| mWorkspaceLoading = value; |
| } |
| |
| public void setWaitingForResult(PendingRequestArgs args) { |
| mPendingRequestArgs = args; |
| } |
| |
| void addAppWidgetFromDropImpl(int appWidgetId, ItemInfo info, AppWidgetHostView boundWidget, |
| WidgetAddFlowHandler addFlowHandler) { |
| if (LOGD) { |
| Log.d(TAG, "Adding widget from drop"); |
| } |
| addAppWidgetImpl(appWidgetId, info, boundWidget, addFlowHandler, 0); |
| } |
| |
| void addAppWidgetImpl(int appWidgetId, ItemInfo info, |
| AppWidgetHostView boundWidget, WidgetAddFlowHandler addFlowHandler, int delay) { |
| if (!addFlowHandler.startConfigActivity(this, appWidgetId, info, REQUEST_CREATE_APPWIDGET)) { |
| // If the configuration flow was not started, add the widget |
| |
| Runnable onComplete = new Runnable() { |
| @Override |
| public void run() { |
| // Exit spring loaded mode if necessary after adding the widget |
| mStateManager.goToState(NORMAL, SPRING_LOADED_EXIT_DELAY); |
| } |
| }; |
| completeAddAppWidget(appWidgetId, info, boundWidget, addFlowHandler.getProviderInfo(this)); |
| mWorkspace.removeExtraEmptyScreenDelayed(true, onComplete, delay, false); |
| } |
| } |
| |
| public void addPendingItem(PendingAddItemInfo info, long container, long screenId, |
| int[] cell, int spanX, int spanY) { |
| info.container = container; |
| info.screenId = screenId; |
| if (cell != null) { |
| info.cellX = cell[0]; |
| info.cellY = cell[1]; |
| } |
| info.spanX = spanX; |
| info.spanY = spanY; |
| |
| switch (info.itemType) { |
| case LauncherSettings.Favorites.ITEM_TYPE_CUSTOM_APPWIDGET: |
| case LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET: |
| addAppWidgetFromDrop((PendingAddWidgetInfo) info); |
| break; |
| case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT: |
| processShortcutFromDrop((PendingAddShortcutInfo) info); |
| break; |
| default: |
| throw new IllegalStateException("Unknown item type: " + info.itemType); |
| } |
| } |
| |
| /** |
| * Process a shortcut drop. |
| */ |
| private void processShortcutFromDrop(PendingAddShortcutInfo info) { |
| Intent intent = new Intent(Intent.ACTION_CREATE_SHORTCUT).setComponent(info.componentName); |
| setWaitingForResult(PendingRequestArgs.forIntent(REQUEST_CREATE_SHORTCUT, intent, info)); |
| if (!info.activityInfo.startConfigActivity(this, REQUEST_CREATE_SHORTCUT)) { |
| handleActivityResult(REQUEST_CREATE_SHORTCUT, RESULT_CANCELED, null); |
| } |
| } |
| |
| /** |
| * Process a widget drop. |
| */ |
| private void addAppWidgetFromDrop(PendingAddWidgetInfo info) { |
| AppWidgetHostView hostView = info.boundWidget; |
| final int appWidgetId; |
| WidgetAddFlowHandler addFlowHandler = info.getHandler(); |
| if (hostView != null) { |
| // In the case where we've prebound the widget, we remove it from the DragLayer |
| if (LOGD) { |
| Log.d(TAG, "Removing widget view from drag layer and setting boundWidget to null"); |
| } |
| getDragLayer().removeView(hostView); |
| |
| appWidgetId = hostView.getAppWidgetId(); |
| addAppWidgetFromDropImpl(appWidgetId, info, hostView, addFlowHandler); |
| |
| // Clear the boundWidget so that it doesn't get destroyed. |
| info.boundWidget = null; |
| } else { |
| // In this case, we either need to start an activity to get permission to bind |
| // the widget, or we need to start an activity to configure the widget, or both. |
| if (FeatureFlags.ENABLE_CUSTOM_WIDGETS && |
| info.itemType == LauncherSettings.Favorites.ITEM_TYPE_CUSTOM_APPWIDGET) { |
| appWidgetId = CustomWidgetParser.getWidgetIdForCustomProvider( |
| this, info.componentName); |
| } else { |
| appWidgetId = getAppWidgetHost().allocateAppWidgetId(); |
| } |
| Bundle options = info.bindOptions; |
| |
| boolean success = mAppWidgetManager.bindAppWidgetIdIfAllowed( |
| appWidgetId, info.info, options); |
| if (success) { |
| addAppWidgetFromDropImpl(appWidgetId, info, null, addFlowHandler); |
| } else { |
| addFlowHandler.startBindFlow(this, appWidgetId, info, REQUEST_BIND_APPWIDGET); |
| } |
| } |
| } |
| |
| FolderIcon addFolder(CellLayout layout, long container, final long screenId, int cellX, |
| int cellY) { |
| final FolderInfo folderInfo = new FolderInfo(); |
| folderInfo.title = getText(R.string.folder_name); |
| |
| // Update the model |
| getModelWriter().addItemToDatabase(folderInfo, container, screenId, cellX, cellY); |
| |
| // Create the view |
| FolderIcon newFolder = FolderIcon.fromXml(R.layout.folder_icon, this, layout, folderInfo); |
| mWorkspace.addInScreen(newFolder, folderInfo); |
| // Force measure the new folder icon |
| CellLayout parent = mWorkspace.getParentCellLayoutForView(newFolder); |
| parent.getShortcutsAndWidgets().measureChild(newFolder); |
| return newFolder; |
| } |
| |
| /** |
| * Unbinds the view for the specified item, and removes the item and all its children. |
| * |
| * @param v the view being removed. |
| * @param itemInfo the {@link ItemInfo} for this view. |
| * @param deleteFromDb whether or not to delete this item from the db. |
| */ |
| public boolean removeItem(View v, final ItemInfo itemInfo, boolean deleteFromDb) { |
| if (itemInfo instanceof ShortcutInfo) { |
| // Remove the shortcut from the folder before removing it from launcher |
| View folderIcon = mWorkspace.getHomescreenIconByItemId(itemInfo.container); |
| if (folderIcon instanceof FolderIcon) { |
| ((FolderInfo) folderIcon.getTag()).remove((ShortcutInfo) itemInfo, true); |
| } else { |
| mWorkspace.removeWorkspaceItem(v); |
| } |
| if (deleteFromDb) { |
| getModelWriter().deleteItemFromDatabase(itemInfo); |
| } |
| } else if (itemInfo instanceof FolderInfo) { |
| final FolderInfo folderInfo = (FolderInfo) itemInfo; |
| if (v instanceof FolderIcon) { |
| ((FolderIcon) v).removeListeners(); |
| } |
| mWorkspace.removeWorkspaceItem(v); |
| if (deleteFromDb) { |
| getModelWriter().deleteFolderAndContentsFromDatabase(folderInfo); |
| } |
| } else if (itemInfo instanceof LauncherAppWidgetInfo) { |
| final LauncherAppWidgetInfo widgetInfo = (LauncherAppWidgetInfo) itemInfo; |
| mWorkspace.removeWorkspaceItem(v); |
| if (deleteFromDb) { |
| deleteWidgetInfo(widgetInfo); |
| } |
| } else { |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * Deletes the widget info and the widget id. |
| */ |
| private void deleteWidgetInfo(final LauncherAppWidgetInfo widgetInfo) { |
| final LauncherAppWidgetHost appWidgetHost = getAppWidgetHost(); |
| if (appWidgetHost != null && !widgetInfo.isCustomWidget() && widgetInfo.isWidgetIdAllocated()) { |
| // Deleting an app widget ID is a void call but writes to disk before returning |
| // to the caller... |
| new AsyncTask<Void, Void, Void>() { |
| public Void doInBackground(Void ... args) { |
| appWidgetHost.deleteAppWidgetId(widgetInfo.appWidgetId); |
| return null; |
| } |
| }.executeOnExecutor(Utilities.THREAD_POOL_EXECUTOR); |
| } |
| getModelWriter().deleteItemFromDatabase(widgetInfo); |
| } |
| |
| @Override |
| public boolean dispatchKeyEvent(KeyEvent event) { |
| return (event.getKeyCode() == KeyEvent.KEYCODE_HOME) || super.dispatchKeyEvent(event); |
| } |
| |
| @Override |
| public void onBackPressed() { |
| if (mLauncherCallbacks != null && mLauncherCallbacks.handleBackPressed()) { |
| return; |
| } |
| |
| if (mDragController.isDragging()) { |
| mDragController.cancelDrag(); |
| return; |
| } |
| |
| // Note: There should be at most one log per method call. This is enforced implicitly |
| // by using if-else statements. |
| UserEventDispatcher ued = getUserEventDispatcher(); |
| AbstractFloatingView topView = AbstractFloatingView.getTopOpenView(this); |
| if (topView != null) { |
| topView.onBackPressed(); |
| } else if (!isInState(NORMAL)) { |
| ued.logActionCommand(Action.Command.BACK, mStateManager.getState().containerType); |
| mStateManager.goToState(NORMAL); |
| } else { |
| // Back button is a no-op here, but give at least some feedback for the button press |
| mWorkspace.showOutlinesTemporarily(); |
| } |
| } |
| |
| /** |
| * Launches the intent referred by the clicked shortcut. |
| * |
| * @param v The view representing the clicked shortcut. |
| */ |
| public void onClick(View v) { |
| // Make sure that rogue clicks don't get through while allapps is launching, or after the |
| // view has detached (it's possible for this to happen if the view is removed mid touch). |
| if (v.getWindowToken() == null) { |
| return; |
| } |
| |
| if (!mWorkspace.isFinishedSwitchingState()) { |
| return; |
| } |
| |
| if (v instanceof Workspace) { |
| if (isInState(OVERVIEW)) { |
| getUserEventDispatcher().logActionOnContainer(LauncherLogProto.Action.Type.TOUCH, |
| LauncherLogProto.Action.Direction.NONE, |
| LauncherLogProto.ContainerType.OVERVIEW, mWorkspace.getCurrentPage()); |
| mStateManager.goToState(NORMAL); |
| } |
| return; |
| } |
| |
| if (v instanceof CellLayout) { |
| if (isInState(OVERVIEW)) { |
| int page = mWorkspace.indexOfChild(v); |
| getUserEventDispatcher().logActionOnContainer(LauncherLogProto.Action.Type.TOUCH, |
| LauncherLogProto.Action.Direction.NONE, |
| LauncherLogProto.ContainerType.OVERVIEW, page); |
| mWorkspace.snapToPageFromOverView(page); |
| mStateManager.goToState(NORMAL); |
| } |
| return; |
| } |
| |
| Object tag = v.getTag(); |
| if (tag instanceof ShortcutInfo) { |
| onClickAppShortcut(v); |
| } else if (tag instanceof FolderInfo) { |
| if (v instanceof FolderIcon) { |
| onClickFolderIcon(v); |
| } |
| } else if ((v instanceof PageIndicator) || |
| (v == mAllAppsButton && mAllAppsButton != null)) { |
| onClickAllAppsButton(v); |
| } else if (tag instanceof AppInfo) { |
| startAppShortcutOrInfoActivity(v); |
| } else if (tag instanceof LauncherAppWidgetInfo) { |
| if (v instanceof PendingAppWidgetHostView) { |
| onClickPendingWidget((PendingAppWidgetHostView) v); |
| } |
| } |
| } |
| |
| @SuppressLint("ClickableViewAccessibility") |
| public boolean onTouch(View v, MotionEvent event) { |
| return false; |
| } |
| |
| /** |
| * Event handler for the app widget view which has not fully restored. |
| */ |
| public void onClickPendingWidget(final PendingAppWidgetHostView v) { |
| if (mIsSafeModeEnabled) { |
| Toast.makeText(this, R.string.safemode_widget_error, Toast.LENGTH_SHORT).show(); |
| return; |
| } |
| |
| final LauncherAppWidgetInfo info = (LauncherAppWidgetInfo) v.getTag(); |
| if (v.isReadyForClickSetup()) { |
| LauncherAppWidgetProviderInfo appWidgetInfo = |
| mAppWidgetManager.findProvider(info.providerName, info.user); |
| if (appWidgetInfo == null) { |
| return; |
| } |
| WidgetAddFlowHandler addFlowHandler = new WidgetAddFlowHandler(appWidgetInfo); |
| |
| if (info.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)) { |
| if (!info.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_ALLOCATED)) { |
| // This should not happen, as we make sure that an Id is allocated during bind. |
| return; |
| } |
| addFlowHandler.startBindFlow(this, info.appWidgetId, info, |
| REQUEST_BIND_PENDING_APPWIDGET); |
| } else { |
| addFlowHandler.startConfigActivity(this, info, REQUEST_RECONFIGURE_APPWIDGET); |
| } |
| } else { |
| final String packageName = info.providerName.getPackageName(); |
| onClickPendingAppItem(v, packageName, info.installProgress >= 0); |
| } |
| } |
| |
| /** |
| * Event handler for the "grid" button or "caret" that appears on the home screen, which |
| * enters all apps mode. In verticalBarLayout the caret can be seen when all apps is open, and |
| * so in that case reverses the action. |
| * |
| * @param v The view that was clicked. |
| */ |
| protected void onClickAllAppsButton(View v) { |
| if (LOGD) Log.d(TAG, "onClickAllAppsButton"); |
| if (!isInState(ALL_APPS)) { |
| getUserEventDispatcher().logActionOnControl(Action.Touch.TAP, |
| ControlType.ALL_APPS_BUTTON); |
| mStateManager.goToState(ALL_APPS); |
| } else { |
| mStateManager.goToState(NORMAL); |
| } |
| } |
| |
| private void onClickPendingAppItem(final View v, final String packageName, |
| boolean downloadStarted) { |
| if (downloadStarted) { |
| // If the download has started, simply direct to the market app. |
| startMarketIntentForPackage(v, packageName); |
| return; |
| } |
| new AlertDialog.Builder(this) |
| .setTitle(R.string.abandoned_promises_title) |
| .setMessage(R.string.abandoned_promise_explanation) |
| .setPositiveButton(R.string.abandoned_search, new DialogInterface.OnClickListener() { |
| @Override |
| public void onClick(DialogInterface dialogInterface, int i) { |
| startMarketIntentForPackage(v, packageName); |
| } |
| }) |
| .setNeutralButton(R.string.abandoned_clean_this, |
| new DialogInterface.OnClickListener() { |
| public void onClick(DialogInterface dialog, int id) { |
| final UserHandle user = Process.myUserHandle(); |
| mWorkspace.removeAbandonedPromise(packageName, user); |
| } |
| }) |
| .create().show(); |
| } |
| |
| private void startMarketIntentForPackage(View v, String packageName) { |
| ItemInfo item = (ItemInfo) v.getTag(); |
| Intent intent = PackageManagerHelper.getMarketIntent(packageName); |
| startActivitySafely(v, intent, item); |
| } |
| |
| /** |
| * Event handler for an app shortcut click. |
| * |
| * @param v The view that was clicked. Must be a tagged with a {@link ShortcutInfo}. |
| */ |
| protected void onClickAppShortcut(final View v) { |
| if (LOGD) Log.d(TAG, "onClickAppShortcut"); |
| Object tag = v.getTag(); |
| if (!(tag instanceof ShortcutInfo)) { |
| throw new IllegalArgumentException("Input must be a Shortcut"); |
| } |
| |
| // Open shortcut |
| final ShortcutInfo shortcut = (ShortcutInfo) tag; |
| |
| if (shortcut.isDisabled != 0) { |
| if ((shortcut.isDisabled & |
| ~ShortcutInfo.FLAG_DISABLED_SUSPENDED & |
| ~ShortcutInfo.FLAG_DISABLED_QUIET_USER) == 0) { |
| // If the app is only disabled because of the above flags, launch activity anyway. |
| // Framework will tell the user why the app is suspended. |
| } else { |
| if (!TextUtils.isEmpty(shortcut.disabledMessage)) { |
| // Use a message specific to this shortcut, if it has one. |
| Toast.makeText(this, shortcut.disabledMessage, Toast.LENGTH_SHORT).show(); |
| return; |
| } |
| // Otherwise just use a generic error message. |
| int error = R.string.activity_not_available; |
| if ((shortcut.isDisabled & ShortcutInfo.FLAG_DISABLED_SAFEMODE) != 0) { |
| error = R.string.safemode_shortcut_error; |
| } else if ((shortcut.isDisabled & ShortcutInfo.FLAG_DISABLED_BY_PUBLISHER) != 0 || |
| (shortcut.isDisabled & ShortcutInfo.FLAG_DISABLED_LOCKED_USER) != 0) { |
| error = R.string.shortcut_not_available; |
| } |
| Toast.makeText(this, error, Toast.LENGTH_SHORT).show(); |
| return; |
| } |
| } |
| |
| // Check for abandoned promise |
| if ((v instanceof BubbleTextView) && shortcut.hasPromiseIconUi()) { |
| String packageName = shortcut.intent.getComponent() != null ? |
| shortcut.intent.getComponent().getPackageName() : shortcut.intent.getPackage(); |
| if (!TextUtils.isEmpty(packageName)) { |
| onClickPendingAppItem(v, packageName, |
| shortcut.hasStatusFlag(ShortcutInfo.FLAG_INSTALL_SESSION_ACTIVE)); |
| return; |
| } |
| } |
| |
| // Start activities |
| startAppShortcutOrInfoActivity(v); |
| } |
| |
| private void startAppShortcutOrInfoActivity(View v) { |
| ItemInfo item = (ItemInfo) v.getTag(); |
| Intent intent; |
| if (item instanceof PromiseAppInfo) { |
| PromiseAppInfo promiseAppInfo = (PromiseAppInfo) item; |
| intent = promiseAppInfo.getMarketIntent(); |
| } else { |
| intent = item.getIntent(); |
| } |
| if (intent == null) { |
| throw new IllegalArgumentException("Input must have a valid intent"); |
| } |
| startActivitySafely(v, intent, item); |
| } |
| |
| /** |
| * Event handler for a folder icon click. |
| * |
| * @param v The view that was clicked. Must be an instance of {@link FolderIcon}. |
| */ |
| protected void onClickFolderIcon(View v) { |
| if (LOGD) Log.d(TAG, "onClickFolder"); |
| if (!(v instanceof FolderIcon)){ |
| throw new IllegalArgumentException("Input must be a FolderIcon"); |
| } |
| |
| Folder folder = ((FolderIcon) v).getFolder(); |
| if (!folder.isOpen() && !folder.isDestroyed()) { |
| // Open the requested folder |
| folder.animateOpen(); |
| } |
| } |
| |
| /** |
| * Event handler for the (Add) Widgets button that appears after a long press |
| * on the home screen. |
| */ |
| public void onClickAddWidgetButton(View view) { |
| if (LOGD) Log.d(TAG, "onClickAddWidgetButton"); |
| if (mIsSafeModeEnabled) { |
| Toast.makeText(this, R.string.safemode_widget_error, Toast.LENGTH_SHORT).show(); |
| } else { |
| WidgetsFullSheet.show(this, true /* animated */); |
| } |
| } |
| |
| /** |
| * Event handler for the wallpaper picker button that appears after a long press |
| * on the home screen. |
| */ |
| public void onClickWallpaperPicker(View v) { |
| if (!Utilities.isWallpaperAllowed(this)) { |
| Toast.makeText(this, R.string.msg_disabled_by_admin, Toast.LENGTH_SHORT).show(); |
| return; |
| } |
| |
| int pageScroll = mWorkspace.getScrollForPage(mWorkspace.getPageNearestToCenterOfScreen()); |
| float offset = mWorkspace.mWallpaperOffset.wallpaperOffsetForScroll(pageScroll); |
| setWaitingForResult(new PendingRequestArgs(new ItemInfo())); |
| Intent intent = new Intent(Intent.ACTION_SET_WALLPAPER) |
| .putExtra(Utilities.EXTRA_WALLPAPER_OFFSET, offset); |
| |
| String pickerPackage = getString(R.string.wallpaper_picker_package); |
| boolean hasTargetPackage = !TextUtils.isEmpty(pickerPackage); |
| if (hasTargetPackage) { |
| intent.setPackage(pickerPackage); |
| } |
| |
| intent.setSourceBounds(getViewBounds(v)); |
| try { |
| startActivityForResult(intent, REQUEST_PICK_WALLPAPER, |
| // If there is no target package, use the default intent chooser animation |
| hasTargetPackage ? getActivityLaunchOptions(v) : null); |
| } catch (ActivityNotFoundException e) { |
| setWaitingForResult(null); |
| Toast.makeText(this, R.string.activity_not_found, Toast.LENGTH_SHORT).show(); |
| } |
| } |
| |
| /** |
| * Event handler for a click on the settings button that appears after a long press |
| * on the home screen. |
| */ |
| public void onClickSettingsButton(View v) { |
| if (LOGD) Log.d(TAG, "onClickSettingsButton"); |
| Intent intent = new Intent(Intent.ACTION_APPLICATION_PREFERENCES) |
| .setPackage(getPackageName()); |
| intent.setSourceBounds(getViewBounds(v)); |
| intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); |
| startActivity(intent, getActivityLaunchOptions(v)); |
| } |
| |
| @Override |
| public void onAccessibilityStateChanged(boolean enabled) { |
| mDragLayer.onAccessibilityStateChanged(enabled); |
| } |
| |
| private void startShortcutIntentSafely(Intent intent, Bundle optsBundle, ItemInfo info) { |
| try { |
| StrictMode.VmPolicy oldPolicy = StrictMode.getVmPolicy(); |
| try { |
| // Temporarily disable deathPenalty on all default checks. For eg, shortcuts |
| // containing file Uri's would cause a crash as penaltyDeathOnFileUriExposure |
| // is enabled by default on NYC. |
| StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder().detectAll() |
| .penaltyLog().build()); |
| |
| if (info.itemType == LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT) { |
| String id = ((ShortcutInfo) info).getDeepShortcutId(); |
| String packageName = intent.getPackage(); |
| DeepShortcutManager.getInstance(this).startShortcut( |
| packageName, id, intent.getSourceBounds(), optsBundle, info.user); |
| } else { |
| // Could be launching some bookkeeping activity |
| startActivity(intent, optsBundle); |
| } |
| } finally { |
| StrictMode.setVmPolicy(oldPolicy); |
| } |
| } catch (SecurityException e) { |
| // Due to legacy reasons, direct call shortcuts require Launchers to have the |
| // corresponding permission. Show the appropriate permission prompt if that |
| // is the case. |
| if (intent.getComponent() == null |
| && Intent.ACTION_CALL.equals(intent.getAction()) |
| && checkSelfPermission(Manifest.permission.CALL_PHONE) != |
| PackageManager.PERMISSION_GRANTED) { |
| |
| setWaitingForResult(PendingRequestArgs |
| .forIntent(REQUEST_PERMISSION_CALL_PHONE, intent, info)); |
| requestPermissions(new String[]{Manifest.permission.CALL_PHONE}, |
| REQUEST_PERMISSION_CALL_PHONE); |
| } else { |
| // No idea why this was thrown. |
| throw e; |
| } |
| } |
| } |
| |
| @TargetApi(Build.VERSION_CODES.M) |
| public Bundle getActivityLaunchOptions(View v) { |
| if (Utilities.ATLEAST_MARSHMALLOW) { |
| int left = 0, top = 0; |
| int width = v.getMeasuredWidth(), height = v.getMeasuredHeight(); |
| if (v instanceof BubbleTextView) { |
| // Launch from center of icon, not entire view |
| Drawable icon = ((BubbleTextView) v).getIcon(); |
| if (icon != null) { |
| Rect bounds = icon.getBounds(); |
| left = (width - bounds.width()) / 2; |
| top = v.getPaddingTop(); |
| width = bounds.width(); |
| height = bounds.height(); |
| } |
| } |
| return ActivityOptions.makeClipRevealAnimation(v, left, top, width, height).toBundle(); |
| } else if (Utilities.ATLEAST_LOLLIPOP_MR1) { |
| // On L devices, we use the device default slide-up transition. |
| // On L MR1 devices, we use a custom version of the slide-up transition which |
| // doesn't have the delay present in the device default. |
| return ActivityOptions.makeCustomAnimation( |
| this, R.anim.task_open_enter, R.anim.no_anim).toBundle(); |
| } |
| return null; |
| } |
| |
| public Rect getViewBounds(View v) { |
| int[] pos = new int[2]; |
| v.getLocationOnScreen(pos); |
| return new Rect(pos[0], pos[1], pos[0] + v.getWidth(), pos[1] + v.getHeight()); |
| } |
| |
| public boolean startActivitySafely(View v, Intent intent, ItemInfo item) { |
| mAppLaunchSuccess = false; |
| if (mIsSafeModeEnabled && !Utilities.isSystemApp(this, intent)) { |
| Toast.makeText(this, R.string.safemode_shortcut_error, Toast.LENGTH_SHORT).show(); |
| return mAppLaunchSuccess; |
| } |
| // Only launch using the new animation if the shortcut has not opted out (this is a |
| // private contract between launcher and may be ignored in the future). |
| boolean useLaunchAnimation = (v != null) && |
| !intent.hasExtra(INTENT_EXTRA_IGNORE_LAUNCH_ANIMATION); |
| Bundle optsBundle = useLaunchAnimation ? getActivityLaunchOptions(v) : null; |
| |
| UserHandle user = item == null ? null : item.user; |
| |
| // Prepare intent |
| intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); |
| if (v != null) { |
| intent.setSourceBounds(getViewBounds(v)); |
| } |
| try { |
| if (Utilities.ATLEAST_MARSHMALLOW |
| && (item instanceof ShortcutInfo) |
| && (item.itemType == Favorites.ITEM_TYPE_SHORTCUT |
| || item.itemType == Favorites.ITEM_TYPE_DEEP_SHORTCUT) |
| && !((ShortcutInfo) item).isPromise()) { |
| // Shortcuts need some special checks due to legacy reasons. |
| startShortcutIntentSafely(intent, optsBundle, item); |
| } else if (user == null || user.equals(Process.myUserHandle())) { |
| // Could be launching some bookkeeping activity |
| startActivity(intent, optsBundle); |
| } else { |
| LauncherAppsCompat.getInstance(this).startActivityForProfile( |
| intent.getComponent(), user, intent.getSourceBounds(), optsBundle); |
| } |
| |
| if (v instanceof BubbleTextView) { |
| // This is set to the view that launched the activity that navigated the user away |
| // from launcher. Since there is no callback for when the activity has finished |
| // launching, enable the press state and keep this reference to reset the press |
| // state when we return to launcher. |
| BubbleTextView btv = (BubbleTextView) v; |
| btv.setStayPressed(true); |
| setOnResumeCallback(btv); |
| } |
| mAppLaunchSuccess = true; |
| getUserEventDispatcher().logAppLaunch(v, intent); // TODO for discovered apps b/35802115 |
| } catch (ActivityNotFoundException|SecurityException e) { |
| Toast.makeText(this, R.string.activity_not_found, Toast.LENGTH_SHORT).show(); |
| Log.e(TAG, "Unable to launch. tag=" + item + " intent=" + intent, e); |
| } |
| return mAppLaunchSuccess; |
| } |
| |
| @Override |
| public boolean dispatchTouchEvent(MotionEvent ev) { |
| mLastDispatchTouchEventX = ev.getX(); |
| return super.dispatchTouchEvent(ev); |
| } |
| |
| @Override |
| public boolean onLongClick(View v) { |
| if (!isDraggingEnabled()) return false; |
| if (isWorkspaceLocked()) return false; |
| if (!isInState(NORMAL) && !isInState(OVERVIEW)) return false; |
| |
| boolean ignoreLongPressToOverview = |
| mDeviceProfile.shouldIgnoreLongPressToOverview(mLastDispatchTouchEventX); |
| |
| if (v instanceof Workspace) { |
| if (!isInState(OVERVIEW)) { |
| if (!mWorkspace.isTouchActive() && !ignoreLongPressToOverview) { |
| getUserEventDispatcher().logActionOnContainer(Action.Touch.LONGPRESS, |
| Action.Direction.NONE, ContainerType.WORKSPACE, |
| mWorkspace.getCurrentPage()); |
| getStateManager().goToState(OVERVIEW); |
| mWorkspace.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS, |
| HapticFeedbackConstants.FLAG_IGNORE_VIEW_SETTING); |
| return true; |
| } else { |
| return false; |
| } |
| } else { |
| return false; |
| } |
| } |
| |
| CellLayout.CellInfo longClickCellInfo = null; |
| View itemUnderLongClick = null; |
| if (v.getTag() instanceof ItemInfo) { |
| ItemInfo info = (ItemInfo) v.getTag(); |
| longClickCellInfo = new CellLayout.CellInfo(v, info); |
| itemUnderLongClick = longClickCellInfo.cell; |
| mPendingRequestArgs = null; |
| } |
| |
| // The hotseat touch handling does not go through Workspace, and we always allow long press |
| // on hotseat items. |
| if (!mDragController.isDragging()) { |
| if (itemUnderLongClick == null) { |
| // User long pressed on empty space |
| if (mWorkspace.isPageRearrangeEnabled()) { |
| mWorkspace.startReordering(v); |
| getUserEventDispatcher().logActionOnContainer(Action.Touch.LONGPRESS, |
| Action.Direction.NONE, ContainerType.OVERVIEW); |
| } else { |
| if (ignoreLongPressToOverview) { |
| return false; |
| } |
| getUserEventDispatcher().logActionOnContainer(Action.Touch.LONGPRESS, |
| Action.Direction.NONE, ContainerType.WORKSPACE, |
| mWorkspace.getCurrentPage()); |
| getStateManager().goToState(OVERVIEW); |
| } |
| mWorkspace.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS, |
| HapticFeedbackConstants.FLAG_IGNORE_VIEW_SETTING); |
| } else { |
| final boolean isAllAppsButton = |
| !FeatureFlags.NO_ALL_APPS_ICON && isHotseatLayout(v) && |
| mDeviceProfile.inv.isAllAppsButtonRank(mHotseat.getOrderInHotseat( |
| longClickCellInfo.cellX, longClickCellInfo.cellY)); |
| if (!(itemUnderLongClick instanceof Folder || isAllAppsButton)) { |
| // User long pressed on an item |
| mWorkspace.startDrag(longClickCellInfo, new DragOptions()); |
| } |
| } |
| } |
| return true; |
| } |
| |
| boolean isHotseatLayout(View layout) { |
| // TODO: Remove this method |
| return mHotseat != null && layout != null && |
| (layout instanceof CellLayout) && (layout == mHotseat.getLayout()); |
| } |
| |
| /** |
| * Returns the CellLayout of the specified container at the specified screen. |
| */ |
| public CellLayout getCellLayout(long container, long screenId) { |
| if (container == LauncherSettings.Favorites.CONTAINER_HOTSEAT) { |
| if (mHotseat != null) { |
| return mHotseat.getLayout(); |
| } else { |
| return null; |
| } |
| } else { |
| return mWorkspace.getScreenWithId(screenId); |
| } |
| } |
| |
| @Override |
| public void onTrimMemory(int level) { |
| super.onTrimMemory(level); |
| if (level >= ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN) { |
| // The widget preview db can result in holding onto over |
| // 3MB of memory for caching which isn't necessary. |
| SQLiteDatabase.releaseMemory(); |
| |
| // This clears all widget bitmaps from the widget tray |
| // TODO(hyunyoungs) |
| } |
| if (mLauncherCallbacks != null) { |
| mLauncherCallbacks.onTrimMemory(level); |
| } |
| } |
| |
| @Override |
| public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) { |
| final boolean result = super.dispatchPopulateAccessibilityEvent(event); |
| final List<CharSequence> text = event.getText(); |
| text.clear(); |
| // Populate event with a fake title based on the current state. |
| // TODO: When can workspace be null? |
| text.add(mWorkspace == null |
| ? getString(R.string.all_apps_home_button_label) |
| : mStateManager.getState().getDescription(this)); |
| return result; |
| } |
| |
| /** |
| * If the activity is currently paused, signal that we need to run the passed Runnable |
| * in onResume. |
| * |
| * This needs to be called from incoming places where resources might have been loaded |
| * while the activity is paused. That is because the Configuration (e.g., rotation) might be |
| * wrong when we're not running, and if the activity comes back to what the configuration was |
| * when we were paused, activity is not restarted. |
| * |
| * Implementation of the method from LauncherModel.Callbacks. |
| * |
| * @return {@code true} if we are currently paused. The caller might be able to skip some work |
| */ |
| @Thunk boolean waitUntilResume(Runnable run) { |
| if (mPaused) { |
| if (LOGD) Log.d(TAG, "Deferring update until onResume"); |
| if (run instanceof RunnableWithId) { |
| // Remove any runnables which have the same id |
| while (mBindOnResumeCallbacks.remove(run)) { } |
| } |
| mBindOnResumeCallbacks.add(run); |
| return true; |
| } else { |
| return false; |
| } |
| } |
| |
| public void setOnResumeCallback(OnResumeCallback callback) { |
| if (mOnResumeCallback != null) { |
| mOnResumeCallback.onLauncherResume(); |
| } |
| mOnResumeCallback = callback; |
| } |
| |
| /** |
| * If the activity is currently paused, signal that we need to re-run the loader |
| * in onResume. |
| * |
| * This needs to be called from incoming places where resources might have been loaded |
| * while we are paused. That is becaues the Configuration might be wrong |
| * when we're not running, and if it comes back to what it was when we |
| * were paused, we are not restarted. |
| * |
| * Implementation of the method from LauncherModel.Callbacks. |
| * |
| * @return true if we are currently paused. The caller might be able to |
| * skip some work in that case since we will come back again. |
| */ |
| @Override |
| public boolean setLoadOnResume() { |
| if (mPaused) { |
| if (LOGD) Log.d(TAG, "setLoadOnResume"); |
| mOnResumeNeedsLoad = true; |
| return true; |
| } else { |
| return false; |
| } |
| } |
| |
| /** |
| * Implementation of the method from LauncherModel.Callbacks. |
| */ |
| @Override |
| public int getCurrentWorkspaceScreen() { |
| if (mWorkspace != null) { |
| return mWorkspace.getCurrentPage(); |
| } else { |
| return 0; |
| } |
| } |
| |
| /** |
| * Clear any pending bind callbacks. This is called when is loader is planning to |
| * perform a full rebind from scratch. |
| */ |
| @Override |
| public void clearPendingBinds() { |
| mBindOnResumeCallbacks.clear(); |
| if (mPendingExecutor != null) { |
| mPendingExecutor.markCompleted(); |
| mPendingExecutor = null; |
| } |
| } |
| |
| /** |
| * Refreshes the shortcuts shown on the workspace. |
| * |
| * Implementation of the method from LauncherModel.Callbacks. |
| */ |
| public void startBinding() { |
| TraceHelper.beginSection("startBinding"); |
| // Floating panels (except the full widget sheet) are associated with individual icons. If |
| // we are starting a fresh bind, close all such panels as all the icons are about |
| // to go away. |
| AbstractFloatingView.closeOpenViews(this, true, |
| AbstractFloatingView.TYPE_ALL & ~AbstractFloatingView.TYPE_WIDGETS_FULL_SHEET); |
| |
| setWorkspaceLoading(true); |
| |
| // Clear the workspace because it's going to be rebound |
| mWorkspace.clearDropTargets(); |
| mWorkspace.removeAllWorkspaceScreens(); |
| |
| if (mHotseat != null) { |
| mHotseat.resetLayout(); |
| } |
| TraceHelper.endSection("startBinding"); |
| } |
| |
| @Override |
| public void bindScreens(ArrayList<Long> orderedScreenIds) { |
| // Make sure the first screen is always at the start. |
| if (FeatureFlags.QSB_ON_FIRST_SCREEN && |
| orderedScreenIds.indexOf(Workspace.FIRST_SCREEN_ID) != 0) { |
| orderedScreenIds.remove(Workspace.FIRST_SCREEN_ID); |
| orderedScreenIds.add(0, Workspace.FIRST_SCREEN_ID); |
| LauncherModel.updateWorkspaceScreenOrder(this, orderedScreenIds); |
| } else if (!FeatureFlags.QSB_ON_FIRST_SCREEN && orderedScreenIds.isEmpty()) { |
| // If there are no screens, we need to have an empty screen |
| mWorkspace.addExtraEmptyScreen(); |
| } |
| bindAddScreens(orderedScreenIds); |
| |
| // After we have added all the screens, if the wallpaper was locked to the default state, |
| // then notify to indicate that it can be released and a proper wallpaper offset can be |
| // computed before the next layout |
| mWorkspace.unlockWallpaperFromDefaultPageOnNextLayout(); |
| } |
| |
| private void bindAddScreens(ArrayList<Long> orderedScreenIds) { |
| int count = orderedScreenIds.size(); |
| for (int i = 0; i < count; i++) { |
| long screenId = orderedScreenIds.get(i); |
| if (!FeatureFlags.QSB_ON_FIRST_SCREEN || screenId != Workspace.FIRST_SCREEN_ID) { |
| // No need to bind the first screen, as its always bound. |
| mWorkspace.insertNewWorkspaceScreenBeforeEmptyScreen(screenId); |
| } |
| } |
| } |
| |
| @Override |
| public void bindAppsAdded(final ArrayList<Long> newScreens, |
| final ArrayList<ItemInfo> addNotAnimated, |
| final ArrayList<ItemInfo> addAnimated) { |
| Runnable r = new Runnable() { |
| public void run() { |
| bindAppsAdded(newScreens, addNotAnimated, addAnimated); |
| } |
| }; |
| if (waitUntilResume(r)) { |
| return; |
| } |
| |
| // Add the new screens |
| if (newScreens != null) { |
| bindAddScreens(newScreens); |
| } |
| |
| // We add the items without animation on non-visible pages, and with |
| // animations on the new page (which we will try and snap to). |
| if (addNotAnimated != null && !addNotAnimated.isEmpty()) { |
| bindItems(addNotAnimated, false); |
| } |
| if (addAnimated != null && !addAnimated.isEmpty()) { |
| bindItems(addAnimated, true); |
| } |
| |
| // Remove the extra empty screen |
| mWorkspace.removeExtraEmptyScreen(false, false); |
| } |
| |
| /** |
| * Bind the items start-end from the list. |
| * |
| * Implementation of the method from LauncherModel.Callbacks. |
| */ |
| @Override |
| public void bindItems(final List<ItemInfo> items, final boolean forceAnimateIcons) { |
| Runnable r = new Runnable() { |
| public void run() { |
| bindItems(items, forceAnimateIcons); |
| } |
| }; |
| if (waitUntilResume(r)) { |
| return; |
| } |
| |
| // Get the list of added items and intersect them with the set of items here |
| final AnimatorSet anim = LauncherAnimUtils.createAnimatorSet(); |
| final Collection<Animator> bounceAnims = new ArrayList<>(); |
| final boolean animateIcons = forceAnimateIcons && canRunNewAppsAnimation(); |
| Workspace workspace = mWorkspace; |
| long newItemsScreenId = -1; |
| int end = items.size(); |
| for (int i = 0; i < end; i++) { |
| final ItemInfo item = items.get(i); |
| |
| // Short circuit if we are loading dock items for a configuration which has no dock |
| if (item.container == LauncherSettings.Favorites.CONTAINER_HOTSEAT && |
| mHotseat == null) { |
| continue; |
| } |
| |
| final View view; |
| switch (item.itemType) { |
| case LauncherSettings.Favorites.ITEM_TYPE_APPLICATION: |
| case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT: |
| case LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT: { |
| ShortcutInfo info = (ShortcutInfo) item; |
| view = createShortcut(info); |
| break; |
| } |
| case LauncherSettings.Favorites.ITEM_TYPE_FOLDER: { |
| view = FolderIcon.fromXml(R.layout.folder_icon, this, |
| (ViewGroup) workspace.getChildAt(workspace.getCurrentPage()), |
| (FolderInfo) item); |
| break; |
| } |
| case LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET: |
| case LauncherSettings.Favorites.ITEM_TYPE_CUSTOM_APPWIDGET: { |
| view = inflateAppWidget((LauncherAppWidgetInfo) item); |
| if (view == null) { |
| continue; |
| } |
| break; |
| } |
| default: |
| throw new RuntimeException("Invalid Item Type"); |
| } |
| |
| /* |
| * Remove colliding items. |
| */ |
| if (item.container == LauncherSettings.Favorites.CONTAINER_DESKTOP) { |
| CellLayout cl = mWorkspace.getScreenWithId(item.screenId); |
| if (cl != null && cl.isOccupied(item.cellX, item.cellY)) { |
| View v = cl.getChildAt(item.cellX, item.cellY); |
| Object tag = v.getTag(); |
| String desc = "Collision while binding workspace item: " + item |
| + ". Collides with " + tag; |
| if (FeatureFlags.IS_DOGFOOD_BUILD) { |
| throw (new RuntimeException(desc)); |
| } else { |
| Log.d(TAG, desc); |
| getModelWriter().deleteItemFromDatabase(item); |
| continue; |
| } |
| } |
| } |
| workspace.addInScreenFromBind(view, item); |
| if (animateIcons) { |
| // Animate all the applications up now |
| view.setAlpha(0f); |
| view.setScaleX(0f); |
| view.setScaleY(0f); |
| bounceAnims.add(createNewAppBounceAnimation(view, i)); |
| newItemsScreenId = item.screenId; |
| } |
| } |
| |
| if (animateIcons) { |
| // Animate to the correct page |
| if (newItemsScreenId > -1) { |
| long currentScreenId = mWorkspace.getScreenIdForPageIndex(mWorkspace.getNextPage()); |
| final int newScreenIndex = mWorkspace.getPageIndexForScreenId(newItemsScreenId); |
| final Runnable startBounceAnimRunnable = new Runnable() { |
| public void run() { |
| anim.playTogether(bounceAnims); |
| anim.start(); |
| } |
| }; |
| if (newItemsScreenId != currentScreenId) { |
| // We post the animation slightly delayed to prevent slowdowns |
| // when we are loading right after we return to launcher. |
| mWorkspace.postDelayed(new Runnable() { |
| public void run() { |
| if (mWorkspace != null) { |
| mWorkspace.snapToPage(newScreenIndex); |
| mWorkspace.postDelayed(startBounceAnimRunnable, |
| NEW_APPS_ANIMATION_DELAY); |
| } |
| } |
| }, NEW_APPS_PAGE_MOVE_DELAY); |
| } else { |
| mWorkspace.postDelayed(startBounceAnimRunnable, NEW_APPS_ANIMATION_DELAY); |
| } |
| } |
| } |
| workspace.requestLayout(); |
| } |
| |
| /** |
| * Add the views for a widget to the workspace. |
| */ |
| public void bindAppWidget(LauncherAppWidgetInfo item) { |
| View view = inflateAppWidget(item); |
| if (view != null) { |
| mWorkspace.addInScreen(view, item); |
| mWorkspace.requestLayout(); |
| } |
| } |
| |
| private View inflateAppWidget(LauncherAppWidgetInfo item) { |
| if (mIsSafeModeEnabled) { |
| PendingAppWidgetHostView view = |
| new PendingAppWidgetHostView(this, item, mIconCache, true); |
| prepareAppWidget(view, item); |
| return view; |
| } |
| |
| TraceHelper.beginSection("BIND_WIDGET"); |
| |
| final LauncherAppWidgetProviderInfo appWidgetInfo; |
| |
| if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY)) { |
| // If the provider is not ready, bind as a pending widget. |
| appWidgetInfo = null; |
| } else if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)) { |
| // The widget id is not valid. Try to find the widget based on the provider info. |
| appWidgetInfo = mAppWidgetManager.findProvider(item.providerName, item.user); |
| } else { |
| appWidgetInfo = mAppWidgetManager.getLauncherAppWidgetInfo(item.appWidgetId); |
| } |
| |
| // If the provider is ready, but the width is not yet restored, try to restore it. |
| if (!item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY) && |
| (item.restoreStatus != LauncherAppWidgetInfo.RESTORE_COMPLETED)) { |
| if (appWidgetInfo == null) { |
| Log.d(TAG, "Removing restored widget: id=" + item.appWidgetId |
| + " belongs to component " + item.providerName |
| + ", as the provider is null"); |
| getModelWriter().deleteItemFromDatabase(item); |
| return null; |
| } |
| |
| // If we do not have a valid id, try to bind an id. |
| if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)) { |
| if (!item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_ALLOCATED)) { |
| // Id has not been allocated yet. Allocate a new id. |
| item.appWidgetId = mAppWidgetHost.allocateAppWidgetId(); |
| item.restoreStatus |= LauncherAppWidgetInfo.FLAG_ID_ALLOCATED; |
| |
| // Also try to bind the widget. If the bind fails, the user will be shown |
| // a click to setup UI, which will ask for the bind permission. |
| PendingAddWidgetInfo pendingInfo = new PendingAddWidgetInfo(appWidgetInfo); |
| pendingInfo.spanX = item.spanX; |
| pendingInfo.spanY = item.spanY; |
| pendingInfo.minSpanX = item.minSpanX; |
| pendingInfo.minSpanY = item.minSpanY; |
| Bundle options = WidgetHostViewLoader.getDefaultOptionsForWidget(this, pendingInfo); |
| |
| boolean isDirectConfig = |
| item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_DIRECT_CONFIG); |
| if (isDirectConfig && item.bindOptions != null) { |
| Bundle newOptions = item.bindOptions.getExtras(); |
| if (options != null) { |
| newOptions.putAll(options); |
| } |
| options = newOptions; |
| } |
| boolean success = mAppWidgetManager.bindAppWidgetIdIfAllowed( |
| item.appWidgetId, appWidgetInfo, options); |
| |
| // We tried to bind once. If we were not able to bind, we would need to |
| // go through the permission dialog, which means we cannot skip the config |
| // activity. |
| item.bindOptions = null; |
| item.restoreStatus &= ~LauncherAppWidgetInfo.FLAG_DIRECT_CONFIG; |
| |
| // Bind succeeded |
| if (success) { |
| // If the widget has a configure activity, it is still needs to set it up, |
| // otherwise the widget is ready to go. |
| item.restoreStatus = (appWidgetInfo.configure == null) || isDirectConfig |
| ? LauncherAppWidgetInfo.RESTORE_COMPLETED |
| : LauncherAppWidgetInfo.FLAG_UI_NOT_READY; |
| } |
| |
| getModelWriter().updateItemInDatabase(item); |
| } |
| } else if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_UI_NOT_READY) |
| && (appWidgetInfo.configure == null)) { |
| // The widget was marked as UI not ready, but there is no configure activity to |
| // update the UI. |
| item.restoreStatus = LauncherAppWidgetInfo.RESTORE_COMPLETED; |
| getModelWriter().updateItemInDatabase(item); |
| } |
| } |
| |
| final AppWidgetHostView view; |
| if (item.restoreStatus == LauncherAppWidgetInfo.RESTORE_COMPLETED) { |
| // Verify that we own the widget |
| if (appWidgetInfo == null) { |
| FileLog.e(TAG, "Removing invalid widget: id=" + item.appWidgetId); |
| deleteWidgetInfo(item); |
| return null; |
| } |
| |
| item.minSpanX = appWidgetInfo.minSpanX; |
| item.minSpanY = appWidgetInfo.minSpanY; |
| view = mAppWidgetHost.createView(this, item.appWidgetId, appWidgetInfo); |
| } else { |
| view = new PendingAppWidgetHostView(this, item, mIconCache, false); |
| } |
| prepareAppWidget(view, item); |
| |
| TraceHelper.endSection("BIND_WIDGET", "id=" + item.appWidgetId); |
| return view; |
| } |
| |
| /** |
| * Restores a pending widget. |
| * |
| * @param appWidgetId The app widget id |
| */ |
| private LauncherAppWidgetInfo completeRestoreAppWidget(int appWidgetId, int finalRestoreFlag) { |
| LauncherAppWidgetHostView view = mWorkspace.getWidgetForAppWidgetId(appWidgetId); |
| if ((view == null) || !(view instanceof PendingAppWidgetHostView)) { |
| Log.e(TAG, "Widget update called, when the widget no longer exists."); |
| return null; |
| } |
| |
| LauncherAppWidgetInfo info = (LauncherAppWidgetInfo) view.getTag(); |
| info.restoreStatus = finalRestoreFlag; |
| if (info.restoreStatus == LauncherAppWidgetInfo.RESTORE_COMPLETED) { |
| info.pendingItemInfo = null; |
| } |
| |
| if (((PendingAppWidgetHostView) view).isReinflateIfNeeded()) { |
| view.reinflate(); |
| } |
| |
| getModelWriter().updateItemInDatabase(info); |
| return info; |
| } |
| |
| public void onPageBoundSynchronously(int page) { |
| mSynchronouslyBoundPages.add(page); |
| } |
| |
| @Override |
| public void executeOnNextDraw(ViewOnDrawExecutor executor) { |
| if (mPendingExecutor != null) { |
| mPendingExecutor.markCompleted(); |
| } |
| mPendingExecutor = executor; |
| executor.attachTo(this); |
| } |
| |
| public void clearPendingExecutor(ViewOnDrawExecutor executor) { |
| if (mPendingExecutor == executor) { |
| mPendingExecutor = null; |
| } |
| } |
| |
| @Override |
| public void finishFirstPageBind(final ViewOnDrawExecutor executor) { |
| Runnable r = new Runnable() { |
| public void run() { |
| finishFirstPageBind(executor); |
| } |
| }; |
| if (waitUntilResume(r)) { |
| return; |
| } |
| |
| Runnable onComplete = new Runnable() { |
| @Override |
| public void run() { |
| if (executor != null) { |
| executor.onLoadAnimationCompleted(); |
| } |
| } |
| }; |
| if (mDragLayer.getAlpha() < 1) { |
| mDragLayer.animate().alpha(1).withEndAction(onComplete).start(); |
| } else { |
| onComplete.run(); |
| } |
| } |
| |
| /** |
| * Callback saying that there aren't any more items to bind. |
| * |
| * Implementation of the method from LauncherModel.Callbacks. |
| */ |
| public void finishBindingItems() { |
| Runnable r = new Runnable() { |
| public void run() { |
| finishBindingItems(); |
| } |
| }; |
| if (waitUntilResume(r)) { |
| return; |
| } |
| TraceHelper.beginSection("finishBindingItems"); |
| mWorkspace.restoreInstanceStateForRemainingPages(); |
| |
| setWorkspaceLoading(false); |
| |
| if (mPendingActivityResult != null) { |
| handleActivityResult(mPendingActivityResult.requestCode, |
| mPendingActivityResult.resultCode, mPendingActivityResult.data); |
| mPendingActivityResult = null; |
| } |
| |
| InstallShortcutReceiver.disableAndFlushInstallQueue( |
| InstallShortcutReceiver.FLAG_LOADER_RUNNING, this); |
| |
| NotificationListener.setNotificationsChangedListener(mPopupDataProvider); |
| TraceHelper.endSection("finishBindingItems"); |
| } |
| |
| private boolean canRunNewAppsAnimation() { |
| long diff = System.currentTimeMillis() - mDragController.getLastGestureUpTime(); |
| return diff > (NEW_APPS_ANIMATION_INACTIVE_TIMEOUT_SECONDS * 1000); |
| } |
| |
| private ValueAnimator createNewAppBounceAnimation(View v, int i) { |
| ValueAnimator bounceAnim = LauncherAnimUtils.ofViewAlphaAndScale(v, 1, 1, 1); |
| bounceAnim.setDuration(InstallShortcutReceiver.NEW_SHORTCUT_BOUNCE_DURATION); |
| bounceAnim.setStartDelay(i * InstallShortcutReceiver.NEW_SHORTCUT_STAGGER_DELAY); |
| bounceAnim.setInterpolator(new OvershootInterpolator(BOUNCE_ANIMATION_TENSION)); |
| return bounceAnim; |
| } |
| |
| public boolean useVerticalBarLayout() { |
| return mDeviceProfile.isVerticalBarLayout(); |
| } |
| |
| /** |
| * Add the icons for all apps. |
| * |
| * Implementation of the method from LauncherModel.Callbacks. |
| */ |
| public void bindAllApplications(final ArrayList<AppInfo> apps) { |
| Runnable r = new RunnableWithId(RUNNABLE_ID_BIND_APPS) { |
| public void run() { |
| bindAllApplications(apps); |
| } |
| }; |
| if (waitUntilResume(r)) { |
| return; |
| } |
| |
| if (mAppsView != null) { |
| Executor pendingExecutor = getPendingExecutor(); |
| if (pendingExecutor != null && !isInState(ALL_APPS)) { |
| // Wait until the fade in animation has finished before setting all apps list. |
| pendingExecutor.execute(r); |
| return; |
| } |
| |
| mAppsView.setApps(apps); |
| } |
| if (mLauncherCallbacks != null) { |
| mLauncherCallbacks.bindAllApplications(apps); |
| } |
| } |
| |
| /** |
| * Returns an Executor that will run after the launcher is first drawn (including after the |
| * initial fade in animation). Returns null if the first draw has already occurred. |
| */ |
| public @Nullable Executor getPendingExecutor() { |
| return mPendingExecutor != null && mPendingExecutor.canQueue() ? mPendingExecutor : null; |
| } |
| |
| /** |
| * Copies LauncherModel's map of activities to shortcut ids to Launcher's. This is necessary |
| * because LauncherModel's map is updated in the background, while Launcher runs on the UI. |
| */ |
| @Override |
| public void bindDeepShortcutMap(MultiHashMap<ComponentKey, String> deepShortcutMapCopy) { |
| mPopupDataProvider.setDeepShortcutMap(deepShortcutMapCopy); |
| } |
| |
| /** |
| * A package was updated. |
| * |
| * Implementation of the method from LauncherModel.Callbacks. |
| */ |
| public void bindAppsAddedOrUpdated(final ArrayList<AppInfo> apps) { |
| Runnable r = new Runnable() { |
| public void run() { |
| bindAppsAddedOrUpdated(apps); |
| } |
| }; |
| if (waitUntilResume(r)) { |
| return; |
| } |
| |
| if (mAppsView != null) { |
| mAppsView.addOrUpdateApps(apps); |
| } |
| } |
| |
| @Override |
| public void bindPromiseAppProgressUpdated(final PromiseAppInfo app) { |
| Runnable r = new Runnable() { |
| public void run() { |
| bindPromiseAppProgressUpdated(app); |
| } |
| }; |
| if (waitUntilResume(r)) { |
| return; |
| } |
| |
| if (mAppsView != null) { |
| mAppsView.updatePromiseAppProgress(app); |
| } |
| } |
| |
| @Override |
| public void bindWidgetsRestored(final ArrayList<LauncherAppWidgetInfo> widgets) { |
| Runnable r = new Runnable() { |
| public void run() { |
| bindWidgetsRestored(widgets); |
| } |
| }; |
| if (waitUntilResume(r)) { |
| return; |
| } |
| mWorkspace.widgetsRestored(widgets); |
| } |
| |
| /** |
| * Some shortcuts were updated in the background. |
| * Implementation of the method from LauncherModel.Callbacks. |
| * |
| * @param updated list of shortcuts which have changed. |
| */ |
| @Override |
| public void bindShortcutsChanged(final ArrayList<ShortcutInfo> updated, final UserHandle user) { |
| Runnable r = new Runnable() { |
| public void run() { |
| bindShortcutsChanged(updated, user); |
| } |
| }; |
| if (waitUntilResume(r)) { |
| return; |
| } |
| |
| if (!updated.isEmpty()) { |
| mWorkspace.updateShortcuts(updated); |
| } |
| } |
| |
| /** |
| * Update the state of a package, typically related to install state. |
| * |
| * Implementation of the method from LauncherModel.Callbacks. |
| */ |
| @Override |
| public void bindRestoreItemsChange(final HashSet<ItemInfo> updates) { |
| Runnable r = new Runnable() { |
| public void run() { |
| bindRestoreItemsChange(updates); |
| } |
| }; |
| if (waitUntilResume(r)) { |
| return; |
| } |
| |
| mWorkspace.updateRestoreItems(updates); |
| } |
| |
| /** |
| * A package was uninstalled/updated. We take both the super set of packageNames |
| * in addition to specific applications to remove, the reason being that |
| * this can be called when a package is updated as well. In that scenario, |
| * we only remove specific components from the workspace and hotseat, where as |
| * package-removal should clear all items by package name. |
| */ |
| @Override |
| public void bindWorkspaceComponentsRemoved(final ItemInfoMatcher matcher) { |
| Runnable r = new Runnable() { |
| public void run() { |
| bindWorkspaceComponentsRemoved(matcher); |
| } |
| }; |
| if (waitUntilResume(r)) { |
| return; |
| } |
| mWorkspace.removeItemsByMatcher(matcher); |
| mDragController.onAppsRemoved(matcher); |
| } |
| |
| @Override |
| public void bindAppInfosRemoved(final ArrayList<AppInfo> appInfos) { |
| Runnable r = new Runnable() { |
| public void run() { |
| bindAppInfosRemoved(appInfos); |
| } |
| }; |
| if (waitUntilResume(r)) { |
| return; |
| } |
| |
| // Update AllApps |
| if (mAppsView != null) { |
| mAppsView.removeApps(appInfos); |
| } |
| } |
| |
| @Override |
| public void bindAllWidgets(final ArrayList<WidgetListRowEntry> allWidgets) { |
| mPopupDataProvider.setAllWidgets(allWidgets); |
| Runnable r = new RunnableWithId(RUNNABLE_ID_BIND_WIDGETS) { |
| @Override |
| public void run() { |
| bindAllWidgets(allWidgets); |
| } |
| }; |
| if (waitUntilResume(r)) { |
| return; |
| } |
| |
| AbstractFloatingView topView = AbstractFloatingView.getTopOpenView(this); |
| if (topView != null) { |
| topView.onWidgetsBound(); |
| } |
| } |
| |
| /** |
| * @param packageUser if null, refreshes all widgets and shortcuts, otherwise only |
| * refreshes the widgets and shortcuts associated with the given package/user |
| */ |
| public void refreshAndBindWidgetsForPackageUser(@Nullable PackageUserKey packageUser) { |
| mModel.refreshAndBindWidgetsAndShortcuts(packageUser); |
| } |
| |
| public boolean isRotationEnabled () { |
| return mRotationEnabled; |
| } |
| |
| private boolean shouldShowDiscoveryBounce() { |
| return isInState(NORMAL) |
| && !mSharedPrefs.getBoolean(AllAppsState.APPS_VIEW_SHOWN, false) |
| && !UserManagerCompat.getInstance(this).isDemoUser(); |
| } |
| |
| /** |
| * $ adb shell dumpsys activity com.android.launcher3.Launcher [--all] |
| */ |
| @Override |
| public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) { |
| super.dump(prefix, fd, writer, args); |
| |
| if (args.length > 0 && TextUtils.equals(args[0], "--all")) { |
| writer.println(prefix + "Workspace Items"); |
| for (int i = 0; i < mWorkspace.getPageCount(); i++) { |
| writer.println(prefix + " Homescreen " + i); |
| |
| ViewGroup layout = ((CellLayout) mWorkspace.getPageAt(i)).getShortcutsAndWidgets(); |
| for (int j = 0; j < layout.getChildCount(); j++) { |
| Object tag = layout.getChildAt(j).getTag(); |
| if (tag != null) { |
| writer.println(prefix + " " + tag.toString()); |
| } |
| } |
| } |
| |
| writer.println(prefix + " Hotseat"); |
| ViewGroup layout = mHotseat.getLayout().getShortcutsAndWidgets(); |
| for (int j = 0; j < layout.getChildCount(); j++) { |
| Object tag = layout.getChildAt(j).getTag(); |
| if (tag != null) { |
| writer.println(prefix + " " + tag.toString()); |
| } |
| } |
| |
| try { |
| FileLog.flushAll(writer); |
| } catch (Exception e) { |
| // Ignore |
| } |
| } |
| |
| writer.println(prefix + "Misc:"); |
| writer.print(prefix + "\tmWorkspaceLoading=" + mWorkspaceLoading); |
| writer.print(" mPendingRequestArgs=" + mPendingRequestArgs); |
| writer.println(" mPendingActivityResult=" + mPendingActivityResult); |
| |
| mModel.dumpState(prefix, fd, writer, args); |
| |
| if (mLauncherCallbacks != null) { |
| mLauncherCallbacks.dump(prefix, fd, writer, args); |
| } |
| } |
| |
| @Override |
| @TargetApi(Build.VERSION_CODES.N) |
| public void onProvideKeyboardShortcuts( |
| List<KeyboardShortcutGroup> data, Menu menu, int deviceId) { |
| |
| ArrayList<KeyboardShortcutInfo> shortcutInfos = new ArrayList<>(); |
| if (isInState(NORMAL)) { |
| shortcutInfos.add(new KeyboardShortcutInfo(getString(R.string.all_apps_button_label), |
| KeyEvent.KEYCODE_A, KeyEvent.META_CTRL_ON)); |
| } |
| View currentFocus = getCurrentFocus(); |
| if (new CustomActionsPopup(this, currentFocus).canShow()) { |
| shortcutInfos.add(new KeyboardShortcutInfo(getString(R.string.custom_actions), |
| KeyEvent.KEYCODE_O, KeyEvent.META_CTRL_ON)); |
| } |
| if (currentFocus.getTag() instanceof ItemInfo |
| && DeepShortcutManager.supportsShortcuts((ItemInfo) currentFocus.getTag())) { |
| shortcutInfos.add(new KeyboardShortcutInfo(getString(R.string.action_deep_shortcut), |
| KeyEvent.KEYCODE_S, KeyEvent.META_CTRL_ON)); |
| } |
| if (!shortcutInfos.isEmpty()) { |
| data.add(new KeyboardShortcutGroup(getString(R.string.home_screen), shortcutInfos)); |
| } |
| |
| super.onProvideKeyboardShortcuts(data, menu, deviceId); |
| } |
| |
| @Override |
| public boolean onKeyShortcut(int keyCode, KeyEvent event) { |
| if (event.hasModifiers(KeyEvent.META_CTRL_ON)) { |
| switch (keyCode) { |
| case KeyEvent.KEYCODE_A: |
| if (isInState(NORMAL)) { |
| getStateManager().goToState(ALL_APPS); |
| return true; |
| } |
| break; |
| case KeyEvent.KEYCODE_S: { |
| View focusedView = getCurrentFocus(); |
| if (focusedView instanceof BubbleTextView |
| && focusedView.getTag() instanceof ItemInfo |
| && mAccessibilityDelegate.performAction(focusedView, |
| (ItemInfo) focusedView.getTag(), |
| LauncherAccessibilityDelegate.DEEP_SHORTCUTS)) { |
| BaseActionPopup.getOpen(this).requestFocus(); |
| return true; |
| } |
| break; |
| } |
| case KeyEvent.KEYCODE_O: |
| if (new CustomActionsPopup(this, getCurrentFocus()).show()) { |
| return true; |
| } |
| break; |
| } |
| } |
| return super.onKeyShortcut(keyCode, event); |
| } |
| |
| public static Launcher getLauncher(Context context) { |
| if (context instanceof Launcher) { |
| return (Launcher) context; |
| } |
| return ((Launcher) ((ContextWrapper) context).getBaseContext()); |
| } |
| |
| private class RotationPrefChangeHandler implements OnSharedPreferenceChangeListener { |
| |
| @Override |
| public void onSharedPreferenceChanged( |
| SharedPreferences sharedPreferences, String key) { |
| if (Utilities.ALLOW_ROTATION_PREFERENCE_KEY.equals(key)) { |
| // Recreate the activity so that it initializes the rotation preference again. |
| recreate(); |
| } |
| } |
| } |
| |
| /** |
| * Callback for listening for onResume |
| */ |
| public interface OnResumeCallback { |
| |
| void onLauncherResume(); |
| } |
| } |