1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
/*
* Copyright (C) 2014 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 android.transition;
import android.animation.Animator;
import android.animation.TimeInterpolator;
import android.content.Context;
import android.graphics.Rect;
import android.util.AttributeSet;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.AccelerateInterpolator;
import android.view.animation.DecelerateInterpolator;
import com.android.internal.R;
/**
* This transition tracks changes to the visibility of target views in the
* start and end scenes and moves views in or out from the edges of the
* scene. Visibility is determined by both the
* {@link View#setVisibility(int)} state of the view as well as whether it
* is parented in the current view hierarchy. Disappearing Views are
* limited as described in {@link Visibility#onDisappear(android.view.ViewGroup,
* TransitionValues, int, TransitionValues, int)}.
* <p>Views move away from the focal View or the center of the Scene if
* no epicenter was provided.</p>
*/
public class Explode extends Visibility {
private static final TimeInterpolator sDecelerate = new DecelerateInterpolator();
private static final TimeInterpolator sAccelerate = new AccelerateInterpolator();
private static final String TAG = "Explode";
private static final String PROPNAME_SCREEN_BOUNDS = "android:explode:screenBounds";
private int[] mTempLoc = new int[2];
public Explode() {
setPropagation(new CircularPropagation());
}
public Explode(Context context, AttributeSet attrs) {
super(context, attrs);
setPropagation(new CircularPropagation());
}
private void captureValues(TransitionValues transitionValues) {
View view = transitionValues.view;
view.getLocationOnScreen(mTempLoc);
int left = mTempLoc[0];
int top = mTempLoc[1];
int right = left + view.getWidth();
int bottom = top + view.getHeight();
transitionValues.values.put(PROPNAME_SCREEN_BOUNDS, new Rect(left, top, right, bottom));
}
@Override
public void captureStartValues(TransitionValues transitionValues) {
super.captureStartValues(transitionValues);
captureValues(transitionValues);
}
@Override
public void captureEndValues(TransitionValues transitionValues) {
super.captureEndValues(transitionValues);
captureValues(transitionValues);
}
@Override
public Animator onAppear(ViewGroup sceneRoot, View view,
TransitionValues startValues, TransitionValues endValues) {
if (endValues == null) {
return null;
}
Rect bounds = (Rect) endValues.values.get(PROPNAME_SCREEN_BOUNDS);
float endX = view.getTranslationX();
float endY = view.getTranslationY();
calculateOut(sceneRoot, bounds, mTempLoc);
float startX = endX + mTempLoc[0];
float startY = endY + mTempLoc[1];
return TranslationAnimationCreator.createAnimation(view, endValues, bounds.left, bounds.top,
startX, startY, endX, endY, sDecelerate, this);
}
@Override
public Animator onDisappear(ViewGroup sceneRoot, View view,
TransitionValues startValues, TransitionValues endValues) {
if (startValues == null) {
return null;
}
Rect bounds = (Rect) startValues.values.get(PROPNAME_SCREEN_BOUNDS);
int viewPosX = bounds.left;
int viewPosY = bounds.top;
float startX = view.getTranslationX();
float startY = view.getTranslationY();
float endX = startX;
float endY = startY;
int[] interruptedPosition = (int[]) startValues.view.getTag(R.id.transitionPosition);
if (interruptedPosition != null) {
// We want to have the end position relative to the interrupted position, not
// the position it was supposed to start at.
endX += interruptedPosition[0] - bounds.left;
endY += interruptedPosition[1] - bounds.top;
bounds.offsetTo(interruptedPosition[0], interruptedPosition[1]);
}
calculateOut(sceneRoot, bounds, mTempLoc);
endX += mTempLoc[0];
endY += mTempLoc[1];
return TranslationAnimationCreator.createAnimation(view, startValues,
viewPosX, viewPosY, startX, startY, endX, endY, sAccelerate, this);
}
private void calculateOut(View sceneRoot, Rect bounds, int[] outVector) {
sceneRoot.getLocationOnScreen(mTempLoc);
int sceneRootX = mTempLoc[0];
int sceneRootY = mTempLoc[1];
int focalX;
int focalY;
Rect epicenter = getEpicenter();
if (epicenter == null) {
focalX = sceneRootX + (sceneRoot.getWidth() / 2)
+ Math.round(sceneRoot.getTranslationX());
focalY = sceneRootY + (sceneRoot.getHeight() / 2)
+ Math.round(sceneRoot.getTranslationY());
} else {
focalX = epicenter.centerX();
focalY = epicenter.centerY();
}
int centerX = bounds.centerX();
int centerY = bounds.centerY();
double xVector = centerX - focalX;
double yVector = centerY - focalY;
if (xVector == 0 && yVector == 0) {
// Random direction when View is centered on focal View.
xVector = (Math.random() * 2) - 1;
yVector = (Math.random() * 2) - 1;
}
double vectorSize = Math.hypot(xVector, yVector);
xVector /= vectorSize;
yVector /= vectorSize;
double maxDistance =
calculateMaxDistance(sceneRoot, focalX - sceneRootX, focalY - sceneRootY);
outVector[0] = (int) Math.round(maxDistance * xVector);
outVector[1] = (int) Math.round(maxDistance * yVector);
}
private static double calculateMaxDistance(View sceneRoot, int focalX, int focalY) {
int maxX = Math.max(focalX, sceneRoot.getWidth() - focalX);
int maxY = Math.max(focalY, sceneRoot.getHeight() - focalY);
return Math.hypot(maxX, maxY);
}
}
|
