| /* |
| * Copyright (C) 2017 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.bubble; |
| |
| import android.animation.Animator; |
| import android.animation.AnimatorSet; |
| import android.animation.ObjectAnimator; |
| import android.graphics.Path; |
| import android.graphics.PointF; |
| import android.graphics.Rect; |
| import android.support.annotation.VisibleForTesting; |
| import android.transition.Transition; |
| import android.transition.TransitionValues; |
| import android.util.Property; |
| import android.view.View; |
| import android.view.ViewGroup; |
| |
| /** Similar to {@link android.transition.ChangeBounds ChangeBounds} but works across windows */ |
| public class ChangeOnScreenBounds extends Transition { |
| |
| @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE) |
| static final String PROPNAME_BOUNDS = "bubble:changeScreenBounds:bounds"; |
| |
| @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE) |
| static final String PROPNAME_SCREEN_X = "bubble:changeScreenBounds:screenX"; |
| |
| @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE) |
| static final String PROPNAME_SCREEN_Y = "bubble:changeScreenBounds:screenY"; |
| |
| static final String PROPNAME_WIDTH = "bubble:changeScreenBounds:width"; |
| static final String PROPNAME_HEIGHT = "bubble:changeScreenBounds:height"; |
| |
| private static final Property<ViewBounds, PointF> TOP_LEFT_PROPERTY = |
| new Property<ViewBounds, PointF>(PointF.class, "topLeft") { |
| @Override |
| public void set(ViewBounds viewBounds, PointF topLeft) { |
| viewBounds.setTopLeft(topLeft); |
| } |
| |
| @Override |
| public PointF get(ViewBounds viewBounds) { |
| return null; |
| } |
| }; |
| |
| private static final Property<ViewBounds, PointF> BOTTOM_RIGHT_PROPERTY = |
| new Property<ViewBounds, PointF>(PointF.class, "bottomRight") { |
| @Override |
| public void set(ViewBounds viewBounds, PointF bottomRight) { |
| viewBounds.setBottomRight(bottomRight); |
| } |
| |
| @Override |
| public PointF get(ViewBounds viewBounds) { |
| return null; |
| } |
| }; |
| private final int[] tempLocation = new int[2]; |
| |
| @Override |
| public void captureStartValues(TransitionValues transitionValues) { |
| captureValuesWithSize(transitionValues); |
| } |
| |
| @Override |
| public void captureEndValues(TransitionValues transitionValues) { |
| captureValuesWithSize(transitionValues); |
| } |
| |
| /** |
| * Capture location (left and top) from {@code values.view} and size (width and height) from |
| * {@code values.values}. If size is not set, use the size of {@code values.view}. |
| */ |
| private void captureValuesWithSize(TransitionValues values) { |
| View view = values.view; |
| |
| if (view.isLaidOut() || view.getWidth() != 0 || view.getHeight() != 0) { |
| Integer width = (Integer) values.values.get(PROPNAME_WIDTH); |
| Integer height = (Integer) values.values.get(PROPNAME_HEIGHT); |
| |
| values.values.put( |
| PROPNAME_BOUNDS, |
| new Rect( |
| view.getLeft(), |
| view.getTop(), |
| width == null ? view.getRight() : view.getLeft() + width, |
| height == null ? view.getBottom() : view.getTop() + height)); |
| values.view.getLocationOnScreen(tempLocation); |
| values.values.put(PROPNAME_SCREEN_X, tempLocation[0]); |
| values.values.put(PROPNAME_SCREEN_Y, tempLocation[1]); |
| } |
| } |
| |
| @Override |
| public Animator createAnimator( |
| ViewGroup sceneRoot, TransitionValues startValues, TransitionValues endValues) { |
| Rect startBounds = (Rect) startValues.values.get(PROPNAME_BOUNDS); |
| Rect endBounds = (Rect) endValues.values.get(PROPNAME_BOUNDS); |
| |
| if (startBounds == null || endBounds == null) { |
| // start or end values were not captured, so don't animate. |
| return null; |
| } |
| |
| // Offset the startBounds by the difference in screen position |
| int startScreenX = (Integer) startValues.values.get(PROPNAME_SCREEN_X); |
| int startScreenY = (Integer) startValues.values.get(PROPNAME_SCREEN_Y); |
| int endScreenX = (Integer) endValues.values.get(PROPNAME_SCREEN_X); |
| int endScreenY = (Integer) endValues.values.get(PROPNAME_SCREEN_Y); |
| startBounds.offset(startScreenX - endScreenX, startScreenY - endScreenY); |
| |
| final int startLeft = startBounds.left; |
| final int endLeft = endBounds.left; |
| final int startTop = startBounds.top; |
| final int endTop = endBounds.top; |
| final int startRight = startBounds.right; |
| final int endRight = endBounds.right; |
| final int startBottom = startBounds.bottom; |
| final int endBottom = endBounds.bottom; |
| ViewBounds viewBounds = new ViewBounds(endValues.view); |
| viewBounds.setTopLeft(new PointF(startLeft, startTop)); |
| viewBounds.setBottomRight(new PointF(startRight, startBottom)); |
| |
| // Animate the top left and bottom right corners along a path |
| Path topLeftPath = getPathMotion().getPath(startLeft, startTop, endLeft, endTop); |
| ObjectAnimator topLeftAnimator = |
| ObjectAnimator.ofObject(viewBounds, TOP_LEFT_PROPERTY, null, topLeftPath); |
| |
| Path bottomRightPath = getPathMotion().getPath(startRight, startBottom, endRight, endBottom); |
| ObjectAnimator bottomRightAnimator = |
| ObjectAnimator.ofObject(viewBounds, BOTTOM_RIGHT_PROPERTY, null, bottomRightPath); |
| AnimatorSet set = new AnimatorSet(); |
| set.playTogether(topLeftAnimator, bottomRightAnimator); |
| return set; |
| } |
| |
| private static class ViewBounds { |
| private int left; |
| private int top; |
| private int right; |
| private int bottom; |
| private final View view; |
| private int topLeftCalls; |
| private int bottomRightCalls; |
| |
| public ViewBounds(View view) { |
| this.view = view; |
| } |
| |
| public void setTopLeft(PointF topLeft) { |
| left = Math.round(topLeft.x); |
| top = Math.round(topLeft.y); |
| topLeftCalls++; |
| if (topLeftCalls == bottomRightCalls) { |
| updateLeftTopRightBottom(); |
| } |
| } |
| |
| public void setBottomRight(PointF bottomRight) { |
| right = Math.round(bottomRight.x); |
| bottom = Math.round(bottomRight.y); |
| bottomRightCalls++; |
| if (topLeftCalls == bottomRightCalls) { |
| updateLeftTopRightBottom(); |
| } |
| } |
| |
| private void updateLeftTopRightBottom() { |
| view.setLeft(left); |
| view.setTop(top); |
| view.setRight(right); |
| view.setBottom(bottom); |
| topLeftCalls = 0; |
| bottomRightCalls = 0; |
| } |
| } |
| } |