quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleDismissController.java - platform/packages/apps/Launcher3 - Git at Google

 /*
  * Copyright (C) 2023 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.taskbar.bubbles;

 import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;

 import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
 import android.animation.ValueAnimator;
 import android.content.res.Resources;
 import android.os.SystemProperties;
 import android.view.MotionEvent;
 import android.view.View;
 import android.widget.FrameLayout;

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

 import com.android.launcher3.R;
 import com.android.launcher3.taskbar.TaskbarActivityContext;
 import com.android.launcher3.taskbar.TaskbarDragLayer;
 import com.android.wm.shell.common.bubbles.DismissView;
 import com.android.wm.shell.common.magnetictarget.MagnetizedObject;

 /**
  * Controls dismiss view presentation for the bubble bar dismiss functionality.
  * Provides the dragged view snapping to the target dismiss area and animates it.
  * When the dragged bubble/bubble stack is realised inside of the target area, it gets dismissed.
  *
  * @see BubbleDragController
  */
 public class BubbleDismissController {
     private static final float FLING_TO_DISMISS_MIN_VELOCITY = 6000f;
     public static final boolean ENABLE_FLING_TO_DISMISS_BUBBLE =
             SystemProperties.getBoolean("persist.wm.debug.fling_to_dismiss_bubble", true);
     private final TaskbarActivityContext mActivity;
     private final TaskbarDragLayer mDragLayer;
     @Nullable
     private BubbleBarViewController mBubbleBarViewController;

     // Dismiss view that's attached to drag layer. It consists of the scrim view and the circular
     // dismiss view used as a dismiss target.
     @Nullable
     private DismissView mDismissView;

     // The currently magnetized object, which is being dragged and will be attracted to the magnetic
     // dismiss target. This is either the stack itself, or an individual bubble.
     @Nullable
     private MagnetizedObject<View> mMagnetizedObject;

     // The MagneticTarget instance for our circular dismiss view. This is added to the
     // MagnetizedObject instances for the stack and any dragged-out bubbles.
     @Nullable
     private MagnetizedObject.MagneticTarget mMagneticTarget;
     @Nullable
     private ValueAnimator mDismissAnimator;

     public BubbleDismissController(TaskbarActivityContext activity, TaskbarDragLayer dragLayer) {
         mActivity = activity;
         mDragLayer = dragLayer;
     }

     /**
      * Initializes dependencies when bubble controllers are created.
      * Should be careful to only access things that were created in constructors for now, as some
      * controllers may still be waiting for init().
      */
     public void init(@NonNull BubbleControllers bubbleControllers) {
         mBubbleBarViewController = bubbleControllers.bubbleBarViewController;
     }

     /**
      * Setup the dismiss view and magnetized object that will be attracted to magnetic target.
      * Should be called before handling events or showing/hiding dismiss view.
      * @param magnetizedView the view to be pulled into target dismiss area
      */
     public void setupDismissView(@NonNull View magnetizedView) {
         setupDismissView();
         setupMagnetizedObject(magnetizedView);
     }

     /**
      * Handle the touch event and pass it to the magnetized object.
      * It should be called after {@code setupDismissView}
      */
     public boolean handleTouchEvent(@NonNull MotionEvent event) {
         return mMagnetizedObject != null && mMagnetizedObject.maybeConsumeMotionEvent(event);
     }

     /**
      * Show dismiss view with animation
      * It should be called after {@code setupDismissView}
      */
     public void showDismissView() {
         if (mDismissView == null) return;
         mDismissView.show();
     }

     /**
      * Hide dismiss view with animation
      * It should be called after {@code setupDismissView}
      */
     public void hideDismissView() {
         if (mDismissView == null) return;
         mDismissView.hide();
     }

     /**
      * Dismiss magnetized object when it's released in the dismiss target area
      */
     private void dismissMagnetizedObject() {
         if (mMagnetizedObject == null || mBubbleBarViewController == null) return;
         if (mMagnetizedObject.getUnderlyingObject() instanceof BubbleView) {
             BubbleView bubbleView = (BubbleView) mMagnetizedObject.getUnderlyingObject();
             if (bubbleView.getBubble() != null) {
                 mBubbleBarViewController.onDismissBubbleWhileDragging(bubbleView.getBubble());
             }
         } else if (mMagnetizedObject.getUnderlyingObject() instanceof BubbleBarView) {
             mBubbleBarViewController.onDismissAllBubblesWhileDragging();
         }
         cleanUpAnimatedViews();
     }

     /**
      * Animate dismiss view when magnetized object gets stuck in the magnetic target
      * @param view captured view
      */
     private void animateDismissCaptured(@NonNull View view) {
         cancelAnimations();
         mDismissAnimator = createDismissAnimator(view);
         mDismissAnimator.start();
     }

     /**
      * Animate dismiss view when magnetized object gets unstuck from the magnetic target
      */
     private void animateDismissReleased() {
         if (mDismissAnimator == null) return;
         mDismissAnimator.removeAllListeners();
         mDismissAnimator.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationCancel(Animator animation) {
                 cancelAnimations();
             }

             @Override
             public void onAnimationEnd(Animator animation) {
                 cancelAnimations();
             }
         });
         mDismissAnimator.reverse();
     }

     /**
      * Cancel and clear dismiss animations and reset view states
      */
     private void cancelAnimations() {
         if (mDismissAnimator == null) return;
         ValueAnimator animator = mDismissAnimator;
         mDismissAnimator = null;
         animator.cancel();
     }

     /**
      * Clean up views changed during animation
      */
     private void cleanUpAnimatedViews() {
         // Cancel animations
         cancelAnimations();
         // Reset dismiss view
         if (mDismissView != null) {
             mDismissView.getCircle().setScaleX(1f);
             mDismissView.getCircle().setScaleY(1f);
         }
         // Reset magnetized view
         if (mMagnetizedObject != null) {
             mMagnetizedObject.getUnderlyingObject().setAlpha(1f);
             mMagnetizedObject.getUnderlyingObject().setScaleX(1f);
             mMagnetizedObject.getUnderlyingObject().setScaleY(1f);
         }
     }

     private void setupDismissView() {
         if (mDismissView != null) return;
         mDismissView = new DismissView(mActivity.getApplicationContext());
         BubbleDismissViewUtils.setup(mDismissView);
         mDragLayer.addView(mDismissView, /* index = */ 0,
                 new FrameLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT));
         setupMagneticTarget(mDismissView.getCircle());
     }

     private void setupMagneticTarget(@NonNull View view) {
         int magneticFieldRadius = mActivity.getResources().getDimensionPixelSize(
                 R.dimen.bubblebar_dismiss_target_size);
         mMagneticTarget = new MagnetizedObject.MagneticTarget(view, magneticFieldRadius);
     }

     private void setupMagnetizedObject(@NonNull View magnetizedView) {
         mMagnetizedObject = new MagnetizedObject<>(mActivity.getApplicationContext(),
                 magnetizedView, 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) {
                 underlyingObject.getLocationOnScreen(loc);
             }
         };

         mMagnetizedObject.setHapticsEnabled(true);
         mMagnetizedObject.setFlingToTargetEnabled(ENABLE_FLING_TO_DISMISS_BUBBLE);
         mMagnetizedObject.setFlingToTargetMinVelocity(FLING_TO_DISMISS_MIN_VELOCITY);
         if (mMagneticTarget != null) {
             mMagnetizedObject.addTarget(mMagneticTarget);
         }
         mMagnetizedObject.setMagnetListener(new MagnetizedObject.MagnetListener() {
             @Override
             public void onStuckToTarget(@NonNull MagnetizedObject.MagneticTarget target) {
                 animateDismissCaptured(magnetizedView);
             }

             @Override
             public void onUnstuckFromTarget(@NonNull MagnetizedObject.MagneticTarget target,
                     float velX, float velY, boolean wasFlungOut) {
                 animateDismissReleased();
             }

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

     private ValueAnimator createDismissAnimator(@NonNull View magnetizedView) {
         Resources resources = mActivity.getResources();
         int expandedSize = resources.getDimensionPixelSize(R.dimen.bubblebar_dismiss_target_size);
         int collapsedSize = resources.getDimensionPixelSize(
                 R.dimen.bubblebar_dismiss_target_small_size);
         float minScale = (float) collapsedSize / expandedSize;
         ValueAnimator animator = ValueAnimator.ofFloat(1f, minScale);
         animator.addUpdateListener(animation -> {
             if (mDismissView == null) return;
             final float animatedValue = (float) animation.getAnimatedValue();
             mDismissView.getCircle().setScaleX(animatedValue);
             mDismissView.getCircle().setScaleY(animatedValue);
             magnetizedView.setAlpha(animatedValue);
             if (magnetizedView instanceof BubbleBarView) {
                 magnetizedView.setScaleX(animatedValue);
                 magnetizedView.setScaleY(animatedValue);
             }
         });
         return animator;
     }
 }
	/*
	* Copyright (C) 2023 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.taskbar.bubbles;

	import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;

	import android.animation.Animator;
	import android.animation.AnimatorListenerAdapter;
	import android.animation.ValueAnimator;
	import android.content.res.Resources;
	import android.os.SystemProperties;
	import android.view.MotionEvent;
	import android.view.View;
	import android.widget.FrameLayout;

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

	import com.android.launcher3.R;
	import com.android.launcher3.taskbar.TaskbarActivityContext;
	import com.android.launcher3.taskbar.TaskbarDragLayer;
	import com.android.wm.shell.common.bubbles.DismissView;
	import com.android.wm.shell.common.magnetictarget.MagnetizedObject;

	/**
	* Controls dismiss view presentation for the bubble bar dismiss functionality.
	* Provides the dragged view snapping to the target dismiss area and animates it.
	* When the dragged bubble/bubble stack is realised inside of the target area, it gets dismissed.
	*
	* @see BubbleDragController
	*/
	public class BubbleDismissController {
	private static final float FLING_TO_DISMISS_MIN_VELOCITY = 6000f;
	public static final boolean ENABLE_FLING_TO_DISMISS_BUBBLE =
	SystemProperties.getBoolean("persist.wm.debug.fling_to_dismiss_bubble", true);
	private final TaskbarActivityContext mActivity;
	private final TaskbarDragLayer mDragLayer;
	@Nullable
	private BubbleBarViewController mBubbleBarViewController;

	// Dismiss view that's attached to drag layer. It consists of the scrim view and the circular
	// dismiss view used as a dismiss target.
	@Nullable
	private DismissView mDismissView;

	// The currently magnetized object, which is being dragged and will be attracted to the magnetic
	// dismiss target. This is either the stack itself, or an individual bubble.
	@Nullable
	private MagnetizedObject<View> mMagnetizedObject;

	// The MagneticTarget instance for our circular dismiss view. This is added to the
	// MagnetizedObject instances for the stack and any dragged-out bubbles.
	@Nullable
	private MagnetizedObject.MagneticTarget mMagneticTarget;
	@Nullable
	private ValueAnimator mDismissAnimator;

	public BubbleDismissController(TaskbarActivityContext activity, TaskbarDragLayer dragLayer) {
	mActivity = activity;
	mDragLayer = dragLayer;
	}

	/**
	* Initializes dependencies when bubble controllers are created.
	* Should be careful to only access things that were created in constructors for now, as some
	* controllers may still be waiting for init().
	*/
	public void init(@NonNull BubbleControllers bubbleControllers) {
	mBubbleBarViewController = bubbleControllers.bubbleBarViewController;
	}

	/**
	* Setup the dismiss view and magnetized object that will be attracted to magnetic target.
	* Should be called before handling events or showing/hiding dismiss view.
	* @param magnetizedView the view to be pulled into target dismiss area
	*/
	public void setupDismissView(@NonNull View magnetizedView) {
	setupDismissView();
	setupMagnetizedObject(magnetizedView);
	}

	/**
	* Handle the touch event and pass it to the magnetized object.
	* It should be called after {@code setupDismissView}
	*/
	public boolean handleTouchEvent(@NonNull MotionEvent event) {
	return mMagnetizedObject != null && mMagnetizedObject.maybeConsumeMotionEvent(event);
	}

	/**
	* Show dismiss view with animation
	* It should be called after {@code setupDismissView}
	*/
	public void showDismissView() {
	if (mDismissView == null) return;
	mDismissView.show();
	}

	/**
	* Hide dismiss view with animation
	* It should be called after {@code setupDismissView}
	*/
	public void hideDismissView() {
	if (mDismissView == null) return;
	mDismissView.hide();
	}

	/**
	* Dismiss magnetized object when it's released in the dismiss target area
	*/
	private void dismissMagnetizedObject() {
	if (mMagnetizedObject == null \|\| mBubbleBarViewController == null) return;
	if (mMagnetizedObject.getUnderlyingObject() instanceof BubbleView) {
	BubbleView bubbleView = (BubbleView) mMagnetizedObject.getUnderlyingObject();
	if (bubbleView.getBubble() != null) {
	mBubbleBarViewController.onDismissBubbleWhileDragging(bubbleView.getBubble());
	}
	} else if (mMagnetizedObject.getUnderlyingObject() instanceof BubbleBarView) {
	mBubbleBarViewController.onDismissAllBubblesWhileDragging();
	}
	cleanUpAnimatedViews();
	}

	/**
	* Animate dismiss view when magnetized object gets stuck in the magnetic target
	* @param view captured view
	*/
	private void animateDismissCaptured(@NonNull View view) {
	cancelAnimations();
	mDismissAnimator = createDismissAnimator(view);
	mDismissAnimator.start();
	}

	/**
	* Animate dismiss view when magnetized object gets unstuck from the magnetic target
	*/
	private void animateDismissReleased() {
	if (mDismissAnimator == null) return;
	mDismissAnimator.removeAllListeners();
	mDismissAnimator.addListener(new AnimatorListenerAdapter() {
	@Override
	public void onAnimationCancel(Animator animation) {
	cancelAnimations();
	}

	@Override
	public void onAnimationEnd(Animator animation) {
	cancelAnimations();
	}
	});
	mDismissAnimator.reverse();
	}

	/**
	* Cancel and clear dismiss animations and reset view states
	*/
	private void cancelAnimations() {
	if (mDismissAnimator == null) return;
	ValueAnimator animator = mDismissAnimator;
	mDismissAnimator = null;
	animator.cancel();
	}

	/**
	* Clean up views changed during animation
	*/
	private void cleanUpAnimatedViews() {
	// Cancel animations
	cancelAnimations();
	// Reset dismiss view
	if (mDismissView != null) {
	mDismissView.getCircle().setScaleX(1f);
	mDismissView.getCircle().setScaleY(1f);
	}
	// Reset magnetized view
	if (mMagnetizedObject != null) {
	mMagnetizedObject.getUnderlyingObject().setAlpha(1f);
	mMagnetizedObject.getUnderlyingObject().setScaleX(1f);
	mMagnetizedObject.getUnderlyingObject().setScaleY(1f);
	}
	}

	private void setupDismissView() {
	if (mDismissView != null) return;
	mDismissView = new DismissView(mActivity.getApplicationContext());
	BubbleDismissViewUtils.setup(mDismissView);
	mDragLayer.addView(mDismissView, /* index = */ 0,
	new FrameLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT));
	setupMagneticTarget(mDismissView.getCircle());
	}

	private void setupMagneticTarget(@NonNull View view) {
	int magneticFieldRadius = mActivity.getResources().getDimensionPixelSize(
	R.dimen.bubblebar_dismiss_target_size);
	mMagneticTarget = new MagnetizedObject.MagneticTarget(view, magneticFieldRadius);
	}

	private void setupMagnetizedObject(@NonNull View magnetizedView) {
	mMagnetizedObject = new MagnetizedObject<>(mActivity.getApplicationContext(),
	magnetizedView, 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) {
	underlyingObject.getLocationOnScreen(loc);
	}
	};

	mMagnetizedObject.setHapticsEnabled(true);
	mMagnetizedObject.setFlingToTargetEnabled(ENABLE_FLING_TO_DISMISS_BUBBLE);
	mMagnetizedObject.setFlingToTargetMinVelocity(FLING_TO_DISMISS_MIN_VELOCITY);
	if (mMagneticTarget != null) {
	mMagnetizedObject.addTarget(mMagneticTarget);
	}
	mMagnetizedObject.setMagnetListener(new MagnetizedObject.MagnetListener() {
	@Override
	public void onStuckToTarget(@NonNull MagnetizedObject.MagneticTarget target) {
	animateDismissCaptured(magnetizedView);
	}

	@Override
	public void onUnstuckFromTarget(@NonNull MagnetizedObject.MagneticTarget target,
	float velX, float velY, boolean wasFlungOut) {
	animateDismissReleased();
	}

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

	private ValueAnimator createDismissAnimator(@NonNull View magnetizedView) {
	Resources resources = mActivity.getResources();
	int expandedSize = resources.getDimensionPixelSize(R.dimen.bubblebar_dismiss_target_size);
	int collapsedSize = resources.getDimensionPixelSize(
	R.dimen.bubblebar_dismiss_target_small_size);
	float minScale = (float) collapsedSize / expandedSize;
	ValueAnimator animator = ValueAnimator.ofFloat(1f, minScale);
	animator.addUpdateListener(animation -> {
	if (mDismissView == null) return;
	final float animatedValue = (float) animation.getAnimatedValue();
	mDismissView.getCircle().setScaleX(animatedValue);
	mDismissView.getCircle().setScaleY(animatedValue);
	magnetizedView.setAlpha(animatedValue);
	if (magnetizedView instanceof BubbleBarView) {
	magnetizedView.setScaleX(animatedValue);
	magnetizedView.setScaleY(animatedValue);
	}
	});
	return animator;
	}
	}