1 /*
2  * Copyright (C) 2010 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 
17 package android.animation;
18 
19 import android.compat.annotation.UnsupportedAppUsage;
20 
21 /**
22  * This evaluator can be used to perform type interpolation between integer
23  * values that represent ARGB colors.
24  */
25 public class ArgbEvaluator implements TypeEvaluator {
26     private static final ArgbEvaluator sInstance = new ArgbEvaluator();
27 
28     /**
29      * Returns an instance of <code>ArgbEvaluator</code> that may be used in
30      * {@link ValueAnimator#setEvaluator(TypeEvaluator)}. The same instance may
31      * be used in multiple <code>Animator</code>s because it holds no state.
32      * @return An instance of <code>ArgbEvalutor</code>.
33      *
34      * @hide
35      */
36     @UnsupportedAppUsage
getInstance()37     public static ArgbEvaluator getInstance() {
38         return sInstance;
39     }
40 
41     /**
42      * This function returns the calculated in-between value for a color
43      * given integers that represent the start and end values in the four
44      * bytes of the 32-bit int. Each channel is separately linearly interpolated
45      * and the resulting calculated values are recombined into the return value.
46      *
47      * @param fraction The fraction from the starting to the ending values
48      * @param startValue A 32-bit int value representing colors in the
49      * separate bytes of the parameter
50      * @param endValue A 32-bit int value representing colors in the
51      * separate bytes of the parameter
52      * @return A value that is calculated to be the linearly interpolated
53      * result, derived by separating the start and end values into separate
54      * color channels and interpolating each one separately, recombining the
55      * resulting values in the same way.
56      */
evaluate(float fraction, Object startValue, Object endValue)57     public Object evaluate(float fraction, Object startValue, Object endValue) {
58         int startInt = (Integer) startValue;
59         float startA = ((startInt >> 24) & 0xff) / 255.0f;
60         float startR = ((startInt >> 16) & 0xff) / 255.0f;
61         float startG = ((startInt >>  8) & 0xff) / 255.0f;
62         float startB = ( startInt        & 0xff) / 255.0f;
63 
64         int endInt = (Integer) endValue;
65         float endA = ((endInt >> 24) & 0xff) / 255.0f;
66         float endR = ((endInt >> 16) & 0xff) / 255.0f;
67         float endG = ((endInt >>  8) & 0xff) / 255.0f;
68         float endB = ( endInt        & 0xff) / 255.0f;
69 
70         // convert from sRGB to linear
71         startR = (float) Math.pow(startR, 2.2);
72         startG = (float) Math.pow(startG, 2.2);
73         startB = (float) Math.pow(startB, 2.2);
74 
75         endR = (float) Math.pow(endR, 2.2);
76         endG = (float) Math.pow(endG, 2.2);
77         endB = (float) Math.pow(endB, 2.2);
78 
79         // compute the interpolated color in linear space
80         float a = startA + fraction * (endA - startA);
81         float r = startR + fraction * (endR - startR);
82         float g = startG + fraction * (endG - startG);
83         float b = startB + fraction * (endB - startB);
84 
85         // convert back to sRGB in the [0..255] range
86         a = a * 255.0f;
87         r = (float) Math.pow(r, 1.0 / 2.2) * 255.0f;
88         g = (float) Math.pow(g, 1.0 / 2.2) * 255.0f;
89         b = (float) Math.pow(b, 1.0 / 2.2) * 255.0f;
90 
91         return Math.round(a) << 24 | Math.round(r) << 16 | Math.round(g) << 8 | Math.round(b);
92     }
93 }