[go: nahoru, domu]
1/*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package android.transition;
18
19import android.animation.Animator;
20import android.animation.AnimatorListenerAdapter;
21import android.animation.ObjectAnimator;
22import android.content.Context;
23import android.content.res.TypedArray;
24import android.util.AttributeSet;
25import android.util.Log;
26import android.view.View;
27import android.view.ViewGroup;
28
29import com.android.internal.R;
30
31/**
32 * This transition tracks changes to the visibility of target views in the
33 * start and end scenes and fades views in or out when they become visible
34 * or non-visible. Visibility is determined by both the
35 * {@link View#setVisibility(int)} state of the view as well as whether it
36 * is parented in the current view hierarchy.
37 *
38 * <p>The ability of this transition to fade out a particular view, and the
39 * way that that fading operation takes place, is based on
40 * the situation of the view in the view hierarchy. For example, if a view was
41 * simply removed from its parent, then the view will be added into a {@link
42 * android.view.ViewGroupOverlay} while fading. If a visible view is
43 * changed to be {@link View#GONE} or {@link View#INVISIBLE}, then the
44 * visibility will be changed to {@link View#VISIBLE} for the duration of
45 * the animation. However, if a view is in a hierarchy which is also altering
46 * its visibility, the situation can be more complicated. In general, if a
47 * view that is no longer in the hierarchy in the end scene still has a
48 * parent (so its parent hierarchy was removed, but it was not removed from
49 * its parent), then it will be left alone to avoid side-effects from
50 * improperly removing it from its parent. The only exception to this is if
51 * the previous {@link Scene} was
52 * {@link Scene#getSceneForLayout(android.view.ViewGroup, int, android.content.Context)
53 * created from a layout resource file}, then it is considered safe to un-parent
54 * the starting scene view in order to fade it out.</p>
55 *
56 * <p>A Fade transition can be described in a resource file by using the
57 * tag <code>fade</code>, along with the standard
58 * attributes of {@link android.R.styleable#Fade} and
59 * {@link android.R.styleable#Transition}.</p>
60 */
61public class Fade extends Visibility {
62    static final String PROPNAME_TRANSITION_ALPHA = "android:fade:transitionAlpha";
63
64    private static boolean DBG = Transition.DBG && false;
65
66    private static final String LOG_TAG = "Fade";
67
68    /**
69     * Fading mode used in {@link #Fade(int)} to make the transition
70     * operate on targets that are appearing. Maybe be combined with
71     * {@link #OUT} to fade both in and out. Equivalent to
72     * {@link Visibility#MODE_IN}.
73     */
74    public static final int IN = Visibility.MODE_IN;
75
76    /**
77     * Fading mode used in {@link #Fade(int)} to make the transition
78     * operate on targets that are disappearing. Maybe be combined with
79     * {@link #IN} to fade both in and out. Equivalent to
80     * {@link Visibility#MODE_OUT}.
81     */
82    public static final int OUT = Visibility.MODE_OUT;
83
84    /**
85     * Constructs a Fade transition that will fade targets in and out.
86     */
87    public Fade() {
88    }
89
90    /**
91     * Constructs a Fade transition that will fade targets in
92     * and/or out, according to the value of fadingMode.
93     *
94     * @param fadingMode The behavior of this transition, a combination of
95     * {@link #IN} and {@link #OUT}.
96     */
97    public Fade(int fadingMode) {
98        setMode(fadingMode);
99    }
100
101    public Fade(Context context, AttributeSet attrs) {
102        super(context, attrs);
103        TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.Fade);
104        int fadingMode = a.getInt(R.styleable.Fade_fadingMode, getMode());
105        setMode(fadingMode);
106    }
107
108    @Override
109    public void captureStartValues(TransitionValues transitionValues) {
110        super.captureStartValues(transitionValues);
111        transitionValues.values.put(PROPNAME_TRANSITION_ALPHA,
112                transitionValues.view.getTransitionAlpha());
113    }
114
115    /**
116     * Utility method to handle creating and running the Animator.
117     */
118    private Animator createAnimation(final View view, float startAlpha, final float endAlpha) {
119        if (startAlpha == endAlpha) {
120            return null;
121        }
122        view.setTransitionAlpha(startAlpha);
123        final ObjectAnimator anim = ObjectAnimator.ofFloat(view, "transitionAlpha", endAlpha);
124        if (DBG) {
125            Log.d(LOG_TAG, "Created animator " + anim);
126        }
127        final FadeAnimatorListener listener = new FadeAnimatorListener(view);
128        anim.addListener(listener);
129        addListener(new TransitionListenerAdapter() {
130            @Override
131            public void onTransitionEnd(Transition transition) {
132                view.setTransitionAlpha(1);
133            }
134        });
135        return anim;
136    }
137
138    @Override
139    public Animator onAppear(ViewGroup sceneRoot, View view,
140            TransitionValues startValues,
141            TransitionValues endValues) {
142        if (DBG) {
143            View startView = (startValues != null) ? startValues.view : null;
144            Log.d(LOG_TAG, "Fade.onAppear: startView, startVis, endView, endVis = " +
145                    startView + ", " + view);
146        }
147        float startAlpha = getStartAlpha(startValues, 0);
148        if (startAlpha == 1) {
149            startAlpha = 0;
150        }
151        return createAnimation(view, startAlpha, 1);
152    }
153
154    @Override
155    public Animator onDisappear(ViewGroup sceneRoot, final View view, TransitionValues startValues,
156            TransitionValues endValues) {
157        float startAlpha = getStartAlpha(startValues, 1);
158        return createAnimation(view, startAlpha, 0);
159    }
160
161    private static float getStartAlpha(TransitionValues startValues, float fallbackValue) {
162        float startAlpha = fallbackValue;
163        if (startValues != null) {
164            Float startAlphaFloat = (Float) startValues.values.get(PROPNAME_TRANSITION_ALPHA);
165            if (startAlphaFloat != null) {
166                startAlpha = startAlphaFloat;
167            }
168        }
169        return startAlpha;
170    }
171
172    private static class FadeAnimatorListener extends AnimatorListenerAdapter {
173        private final View mView;
174        private boolean mLayerTypeChanged = false;
175
176        public FadeAnimatorListener(View view) {
177            mView = view;
178        }
179
180        @Override
181        public void onAnimationStart(Animator animator) {
182            if (mView.hasOverlappingRendering() && mView.getLayerType() == View.LAYER_TYPE_NONE) {
183                mLayerTypeChanged = true;
184                mView.setLayerType(View.LAYER_TYPE_HARDWARE, null);
185            }
186        }
187
188        @Override
189        public void onAnimationEnd(Animator animator) {
190            mView.setTransitionAlpha(1);
191            if (mLayerTypeChanged) {
192                mView.setLayerType(View.LAYER_TYPE_NONE, null);
193            }
194        }
195    }
196}
197