Merge changes from topic "mm_remove_floating_tasks" into tm-qpr-dev (33a70394) · Commits · e / os / android_frameworks_base

libs/WindowManager/Shell/src/com/android/wm/shell/bubbles/BubbleController.java

+47 −15

Original line number	Diff line number	Diff line
		@@ -24,6 +24,7 @@ import static android.view.View.INVISIBLE;
		import static android.view.View.VISIBLE;
		import static android.view.WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS;

		import static com.android.wm.shell.bubbles.Bubble.KEY_APP_BUBBLE;
		import static com.android.wm.shell.bubbles.BubbleDebugConfig.DEBUG_BUBBLE_CONTROLLER;
		import static com.android.wm.shell.bubbles.BubbleDebugConfig.DEBUG_BUBBLE_GESTURE;
		import static com.android.wm.shell.bubbles.BubbleDebugConfig.TAG_BUBBLES;
		@@ -37,7 +38,6 @@ import static com.android.wm.shell.bubbles.Bubbles.DISMISS_NO_LONGER_BUBBLE;
		import static com.android.wm.shell.bubbles.Bubbles.DISMISS_PACKAGE_REMOVED;
		import static com.android.wm.shell.bubbles.Bubbles.DISMISS_SHORTCUT_REMOVED;
		import static com.android.wm.shell.bubbles.Bubbles.DISMISS_USER_CHANGED;
		import static com.android.wm.shell.floating.FloatingTasksController.SHOW_FLOATING_TASKS_AS_BUBBLES;

		import android.annotation.NonNull;
		import android.annotation.UserIdInt;
		@@ -150,6 +150,9 @@ public class BubbleController implements ConfigurationChangeListener {

		private final ShellExecutor mBackgroundExecutor;

		// Whether or not we should show bubbles pinned at the bottom of the screen.
		private boolean mIsBubbleBarEnabled;

		private BubbleLogger mLogger;
		private BubbleData mBubbleData;
		@Nullable private BubbleStackView mStackView;
		@@ -210,7 +213,6 @@ public class BubbleController implements ConfigurationChangeListener {
		/** Drag and drop controller to register listener for onDragStarted. */
		private DragAndDropController mDragAndDropController;


		public BubbleController(Context context,
		ShellInit shellInit,
		ShellCommandHandler shellCommandHandler,
		@@ -526,6 +528,12 @@ public class BubbleController implements ConfigurationChangeListener {
		mDataRepository.removeBubblesForUser(removedUserId, parentUserId);
		}

		// TODO(b/256873975): Should pass this into the constructor once flags are available to shell.
		/** Sets whether the bubble bar is enabled (i.e. bubbles pinned to bottom on large screens). */
		public void setBubbleBarEnabled(boolean enabled) {
		mIsBubbleBarEnabled = enabled;
		}

		/** Whether this userId belongs to the current user. */
		private boolean isCurrentProfile(int userId) {
		return userId == UserHandle.USER_ALL
		@@ -591,7 +599,8 @@ public class BubbleController implements ConfigurationChangeListener {
		}
		mStackView.setUnbubbleConversationCallback(mSysuiProxy::onUnbubbleConversation);
		}
		if (SHOW_FLOATING_TASKS_AS_BUBBLES && mBubblePositioner.isLargeScreen()) {

		if (mIsBubbleBarEnabled && mBubblePositioner.isLargeScreen()) {
		mBubblePositioner.setUsePinnedLocation(true);
		} else {
		mBubblePositioner.setUsePinnedLocation(false);
		@@ -959,14 +968,18 @@ public class BubbleController implements ConfigurationChangeListener {
		}

		/**
		* Adds a bubble for a specific intent. These bubbles are <b>not</b> backed by a notification
		* and remain until the user dismisses the bubble or bubble stack. Only one intent bubble
		* is supported at a time.
		* Adds and expands bubble for a specific intent. These bubbles are <b>not</b> backed by a n
		* otification and remain until the user dismisses the bubble or bubble stack. Only one intent
		* bubble is supported at a time.
		*
		* @param intent the intent to display in the bubble expanded view.
		*/
		public void addAppBubble(Intent intent) {
		public void showAppBubble(Intent intent) {
		if (intent == null \|\| intent.getPackage() == null) return;

		PackageManager packageManager = getPackageManagerForUser(mContext, mCurrentUserId);
		if (!isResizableActivity(intent, packageManager, KEY_APP_BUBBLE)) return;

		Bubble b = new Bubble(intent, UserHandle.of(mCurrentUserId), mMainExecutor);
		b.setShouldAutoExpand(true);
		inflateAndAdd(b, /* suppressFlyout= / true, / showInShade= */ false);
		@@ -1489,18 +1502,23 @@ public class BubbleController implements ConfigurationChangeListener {
		}
		PackageManager packageManager = getPackageManagerForUser(
		context, entry.getStatusBarNotification().getUser().getIdentifier());
		ActivityInfo info =
		intent.getIntent().resolveActivityInfo(packageManager, 0);
		return isResizableActivity(intent.getIntent(), packageManager, entry.getKey());
		}

		static boolean isResizableActivity(Intent intent, PackageManager packageManager, String key) {
		if (intent == null) {
		Log.w(TAG, "Unable to send as bubble: " + key + " null intent");
		return false;
		}
		ActivityInfo info = intent.resolveActivityInfo(packageManager, 0);
		if (info == null) {
		Log.w(TAG, "Unable to send as bubble, "
		+ entry.getKey() + " couldn't find activity info for intent: "
		+ intent);
		Log.w(TAG, "Unable to send as bubble: " + key
		+ " couldn't find activity info for intent: " + intent);
		return false;
		}
		if (!ActivityInfo.isResizeableMode(info.resizeMode)) {
		Log.w(TAG, "Unable to send as bubble, "
		+ entry.getKey() + " activity is not resizable for intent: "
		+ intent);
		Log.w(TAG, "Unable to send as bubble: " + key
		+ " activity is not resizable for intent: " + intent);
		return false;
		}
		return true;
		@@ -1673,6 +1691,13 @@ public class BubbleController implements ConfigurationChangeListener {
		});
		}

		@Override
		public void showAppBubble(Intent intent) {
		mMainExecutor.execute(() -> {
		BubbleController.this.showAppBubble(intent);
		});
		}

		@Override
		public boolean handleDismissalInterception(BubbleEntry entry,
		@Nullable List<BubbleEntry> children, IntConsumer removeCallback,
		@@ -1783,6 +1808,13 @@ public class BubbleController implements ConfigurationChangeListener {
		});
		}

		@Override
		public void setBubbleBarEnabled(boolean enabled) {
		mMainExecutor.execute(() -> {
		BubbleController.this.setBubbleBarEnabled(enabled);
		});
		}

		@Override
		public void onNotificationPanelExpandedChanged(boolean expanded) {
		mMainExecutor.execute(

libs/WindowManager/Shell/src/com/android/wm/shell/bubbles/Bubbles.java

+15 −0

Original line number	Diff line number	Diff line
		@@ -22,6 +22,7 @@ import static java.lang.annotation.ElementType.PARAMETER;
		import static java.lang.annotation.RetentionPolicy.SOURCE;

		import android.app.NotificationChannel;
		import android.content.Intent;
		import android.content.pm.UserInfo;
		import android.os.UserHandle;
		import android.service.notification.NotificationListenerService;
		@@ -107,6 +108,15 @@ public interface Bubbles {
		*/
		void expandStackAndSelectBubble(Bubble bubble);

		/**
		* Adds and expands bubble that is not notification based, but instead based on an intent from
		* the app. The intent must be explicit (i.e. include a package name or fully qualified
		* component class name) and the activity for it should be resizable.
		*
		* @param intent the intent to populate the bubble.
		*/
		void showAppBubble(Intent intent);

		/**
		* @return a bubble that matches the provided shortcutId, if one exists.
		*/
		@@ -232,6 +242,11 @@ public interface Bubbles {
		*/
		void onUserRemoved(int removedUserId);

		/**
		* Sets whether bubble bar should be enabled or not.
		*/
		void setBubbleBarEnabled(boolean enabled);

		/** Listener to find out about stack expansion / collapse events. */
		interface BubbleExpandListener {
		/**

libs/WindowManager/Shell/src/com/android/wm/shell/dagger/WMShellBaseModule.java

+0 −44

Original line number	Diff line number	Diff line
		@@ -24,7 +24,6 @@ import android.content.pm.PackageManager;
		import android.os.Handler;
		import android.os.SystemProperties;
		import android.view.IWindowManager;
		import android.view.WindowManager;

		import com.android.internal.logging.UiEventLogger;
		import com.android.launcher3.icons.IconProvider;
		@@ -65,8 +64,6 @@ import com.android.wm.shell.desktopmode.DesktopModeTaskRepository;
		import com.android.wm.shell.displayareahelper.DisplayAreaHelper;
		import com.android.wm.shell.displayareahelper.DisplayAreaHelperController;
		import com.android.wm.shell.draganddrop.DragAndDropController;
		import com.android.wm.shell.floating.FloatingTasks;
		import com.android.wm.shell.floating.FloatingTasksController;
		import com.android.wm.shell.freeform.FreeformComponents;
		import com.android.wm.shell.fullscreen.FullscreenTaskListener;
		import com.android.wm.shell.hidedisplaycutout.HideDisplayCutoutController;
		@@ -574,47 +571,6 @@ public abstract class WMShellBaseModule {
		return Optional.empty();
		}

		//
		// Floating tasks
		//

		@WMSingleton
		@Provides
		static Optional<FloatingTasks> provideFloatingTasks(
		Optional<FloatingTasksController> floatingTaskController) {
		return floatingTaskController.map((controller) -> controller.asFloatingTasks());
		}

		@WMSingleton
		@Provides
		static Optional<FloatingTasksController> provideFloatingTasksController(Context context,
		ShellInit shellInit,
		ShellController shellController,
		ShellCommandHandler shellCommandHandler,
		Optional<BubbleController> bubbleController,
		WindowManager windowManager,
		ShellTaskOrganizer organizer,
		TaskViewTransitions taskViewTransitions,
		@ShellMainThread ShellExecutor mainExecutor,
		@ShellBackgroundThread ShellExecutor bgExecutor,
		SyncTransactionQueue syncQueue) {
		if (FloatingTasksController.FLOATING_TASKS_ENABLED) {
		return Optional.of(new FloatingTasksController(context,
		shellInit,
		shellController,
		shellCommandHandler,
		bubbleController,
		windowManager,
		organizer,
		taskViewTransitions,
		mainExecutor,
		bgExecutor,
		syncQueue));
		} else {
		return Optional.empty();
		}
		}

		//
		// Starting window
		//

libs/WindowManager/Shell/src/com/android/wm/shell/floating/FloatingDismissController.java

deleted100644 → 0

+0 −259

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 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.wm.shell.floating;

		import android.animation.Animator;
		import android.animation.AnimatorListenerAdapter;
		import android.animation.ValueAnimator;
		import android.content.Context;
		import android.content.res.Resources;
		import android.view.MotionEvent;
		import android.view.View;

		import androidx.annotation.NonNull;
		import androidx.dynamicanimation.animation.DynamicAnimation;

		import com.android.wm.shell.R;
		import com.android.wm.shell.bubbles.DismissView;
		import com.android.wm.shell.common.magnetictarget.MagnetizedObject;
		import com.android.wm.shell.floating.views.FloatingTaskLayer;
		import com.android.wm.shell.floating.views.FloatingTaskView;

		import java.util.Objects;

		/**
		* Controls a floating dismiss circle that has a 'magnetic' field around it, causing views moved
		* close to the target to be stuck to it unless moved out again.
		*/
		public class FloatingDismissController {

		/** Velocity required to dismiss the view without dragging it into the dismiss target. */
		private static final float FLING_TO_DISMISS_MIN_VELOCITY = 4000f;
		/**
		* Max velocity that the view can be moving through the target with to stick (i.e. if it's
		* more than this velocity, it will pass through the target.
		*/
		private static final float STICK_TO_TARGET_MAX_X_VELOCITY = 2000f;
		/**
		* Percentage of the target width to use to determine if an object flung towards the target
		* should dismiss (e.g. if target is 100px and this is set ot 2f, anything flung within a
		* 200px-wide area around the target will be considered 'near' enough get dismissed).
		*/
		private static final float FLING_TO_TARGET_WIDTH_PERCENT = 2f;
		/** Minimum alpha to apply to the view being dismissed when it is in the target. */
		private static final float DISMISS_VIEW_MIN_ALPHA = 0.6f;
		/** Amount to scale down the view being dismissed when it is in the target. */
		private static final float DISMISS_VIEW_SCALE_DOWN_PERCENT = 0.15f;

		private Context mContext;
		private FloatingTasksController mController;
		private FloatingTaskLayer mParent;

		private DismissView mDismissView;
		private ValueAnimator mDismissAnimator;
		private View mViewBeingDismissed;
		private float mDismissSizePercent;
		private float mDismissSize;

		/**
		* The currently magnetized object, which is being dragged and will be attracted to the magnetic
		* dismiss target.
		*/
		private MagnetizedObject<View> mMagnetizedObject;
		/**
		* The MagneticTarget instance for our circular dismiss view. This is added to the
		* MagnetizedObject instances for the view being dragged.
		*/
		private MagnetizedObject.MagneticTarget mMagneticTarget;
		/** Magnet listener that handles animating and dismissing the view. */
		private MagnetizedObject.MagnetListener mFloatingViewMagnetListener;

		public FloatingDismissController(Context context, FloatingTasksController controller,
		FloatingTaskLayer parent) {
		mContext = context;
		mController = controller;
		mParent = parent;
		updateSizes();
		createAndAddDismissView();

		mDismissAnimator = ValueAnimator.ofFloat(1f, 0f);
		mDismissAnimator.addUpdateListener(animation -> {
		final float value = (float) animation.getAnimatedValue();
		if (mDismissView != null) {
		mDismissView.setPivotX((mDismissView.getRight() - mDismissView.getLeft()) / 2f);
		mDismissView.setPivotY((mDismissView.getBottom() - mDismissView.getTop()) / 2f);
		final float scaleValue = Math.max(value, mDismissSizePercent);
		mDismissView.getCircle().setScaleX(scaleValue);
		mDismissView.getCircle().setScaleY(scaleValue);
		}
		if (mViewBeingDismissed != null) {
		// TODO: alpha doesn't actually apply to taskView currently.
		mViewBeingDismissed.setAlpha(Math.max(value, DISMISS_VIEW_MIN_ALPHA));
		mViewBeingDismissed.setScaleX(Math.max(value, DISMISS_VIEW_SCALE_DOWN_PERCENT));
		mViewBeingDismissed.setScaleY(Math.max(value, DISMISS_VIEW_SCALE_DOWN_PERCENT));
		}
		});

		mFloatingViewMagnetListener = new MagnetizedObject.MagnetListener() {
		@Override
		public void onStuckToTarget(
		@NonNull MagnetizedObject.MagneticTarget target) {
		animateDismissing(/* dismissing= */ true);
		}

		@Override
		public void onUnstuckFromTarget(@NonNull MagnetizedObject.MagneticTarget target,
		float velX, float velY, boolean wasFlungOut) {
		animateDismissing(/* dismissing= */ false);
		mParent.onUnstuckFromTarget((FloatingTaskView) mViewBeingDismissed, velX, velY,
		wasFlungOut);
		}

		@Override
		public void onReleasedInTarget(@NonNull MagnetizedObject.MagneticTarget target) {
		doDismiss();
		}
		};
		}

		/** Updates all the sizes used and applies them to the {@link DismissView}. */
		public void updateSizes() {
		Resources res = mContext.getResources();
		mDismissSize = res.getDimensionPixelSize(
		R.dimen.floating_task_dismiss_circle_size);
		final float minDismissSize = res.getDimensionPixelSize(
		R.dimen.floating_dismiss_circle_small);
		mDismissSizePercent = minDismissSize / mDismissSize;

		if (mDismissView != null) {
		mDismissView.updateResources();
		}
		}

		/** Prepares the view being dragged to be magnetic. */
		public void setUpMagneticObject(View viewBeingDragged) {
		mViewBeingDismissed = viewBeingDragged;
		mMagnetizedObject = getMagnetizedView(viewBeingDragged);
		mMagnetizedObject.clearAllTargets();
		mMagnetizedObject.addTarget(mMagneticTarget);
		mMagnetizedObject.setMagnetListener(mFloatingViewMagnetListener);
		}

		/** Shows or hides the dismiss target. */
		public void showDismiss(boolean show) {
		if (show) {
		mDismissView.show();
		} else {
		mDismissView.hide();
		}
		}

		/** Passes the MotionEvent to the magnetized object and returns true if it was consumed. */
		public boolean passEventToMagnetizedObject(MotionEvent event) {
		return mMagnetizedObject != null && mMagnetizedObject.maybeConsumeMotionEvent(event);
		}

		private void createAndAddDismissView() {
		if (mDismissView != null) {
		mParent.removeView(mDismissView);
		}
		mDismissView = new DismissView(mContext);
		mDismissView.setTargetSizeResId(R.dimen.floating_task_dismiss_circle_size);
		mDismissView.updateResources();
		mParent.addView(mDismissView);

		final float dismissRadius = mDismissSize;
		// Save the MagneticTarget instance for the newly set up view - we'll add this to the
		// MagnetizedObjects when the dismiss view gets shown.
		mMagneticTarget = new MagnetizedObject.MagneticTarget(
		mDismissView.getCircle(), (int) dismissRadius);
		}

		private MagnetizedObject<View> getMagnetizedView(View v) {
		if (mMagnetizedObject != null
		&& Objects.equals(mMagnetizedObject.getUnderlyingObject(), v)) {
		// Same view being dragged, we can reuse the magnetic object.
		return mMagnetizedObject;
		}
		MagnetizedObject<View> magnetizedView = new MagnetizedObject<View>(
		mContext,
		v,
		DynamicAnimation.TRANSLATION_X, DynamicAnimation.TRANSLATION_Y
		) {
		@Override
		public float getWidth(@NonNull View underlyingObject) {
		return underlyingObject.getWidth();
		}

		@Override
		public float getHeight(@NonNull View underlyingObject) {
		return underlyingObject.getHeight();
		}

		@Override
		public void getLocationOnScreen(@NonNull View underlyingObject,
		@NonNull int[] loc) {
		loc[0] = (int) underlyingObject.getTranslationX();
		loc[1] = (int) underlyingObject.getTranslationY();
		}
		};
		magnetizedView.setHapticsEnabled(true);
		magnetizedView.setFlingToTargetMinVelocity(FLING_TO_DISMISS_MIN_VELOCITY);
		magnetizedView.setStickToTargetMaxXVelocity(STICK_TO_TARGET_MAX_X_VELOCITY);
		magnetizedView.setFlingToTargetWidthPercent(FLING_TO_TARGET_WIDTH_PERCENT);
		return magnetizedView;
		}

		/** Animates the dismiss treatment on the view being dismissed. */
		private void animateDismissing(boolean shouldDismiss) {
		if (mViewBeingDismissed == null) {
		return;
		}
		if (shouldDismiss) {
		mDismissAnimator.removeAllListeners();
		mDismissAnimator.start();
		} else {
		mDismissAnimator.removeAllListeners();
		mDismissAnimator.addListener(new AnimatorListenerAdapter() {
		@Override
		public void onAnimationEnd(Animator animation) {
		super.onAnimationEnd(animation);
		resetDismissAnimator();
		}
		});
		mDismissAnimator.reverse();
		}
		}

		/** Actually dismisses the view. */
		private void doDismiss() {
		mDismissView.hide();
		mController.removeTask();
		resetDismissAnimator();
		mViewBeingDismissed = null;
		}

		private void resetDismissAnimator() {
		mDismissAnimator.removeAllListeners();
		mDismissAnimator.cancel();
		if (mDismissView != null) {
		mDismissView.cancelAnimators();
		mDismissView.getCircle().setScaleX(1f);
		mDismissView.getCircle().setScaleY(1f);
		}
		}
		}

libs/WindowManager/Shell/src/com/android/wm/shell/floating/FloatingTasks.java

deleted100644 → 0

+0 −36

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 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.wm.shell.floating;

		import android.content.Intent;

		import com.android.wm.shell.common.annotations.ExternalThread;

		/**
		* Interface to interact with floating tasks.
		*/
		@ExternalThread
		public interface FloatingTasks {

		/**
		* Shows, stashes, or un-stashes the floating task depending on state:
		* - If there is no floating task for this intent, it shows the task for the provided intent.
		* - If there is a floating task for this intent, but it's stashed, this un-stashes it.
		* - If there is a floating task for this intent, and it's not stashed, this stashes it.
		*/
		void showOrSetStashed(Intent intent);
		}