1/*
2 * Copyright (C) 2014 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 com.android.systemui.recents.misc;
18
19import android.animation.Animator;
20import android.graphics.Color;
21import android.graphics.Matrix;
22import android.graphics.Rect;
23import android.view.View;
24import com.android.systemui.recents.RecentsConfiguration;
25
26import java.lang.reflect.InvocationTargetException;
27import java.lang.reflect.Method;
28import java.util.ArrayList;
29
30/* Common code */
31public class Utilities {
32
33    // Reflection methods for altering shadows
34    private static Method sPropertyMethod;
35    static {
36        try {
37            Class<?> c = Class.forName("android.view.GLES20Canvas");
38            sPropertyMethod = c.getDeclaredMethod("setProperty", String.class, String.class);
39            if (!sPropertyMethod.isAccessible()) sPropertyMethod.setAccessible(true);
40        } catch (ClassNotFoundException e) {
41            e.printStackTrace();
42        } catch (NoSuchMethodException e) {
43            e.printStackTrace();
44        }
45    }
46
47    /**
48     * Calculates a consistent animation duration (ms) for all animations depending on the movement
49     * of the object being animated.
50     */
51    public static int calculateTranslationAnimationDuration(int distancePx) {
52        return calculateTranslationAnimationDuration(distancePx, 100);
53    }
54    public static int calculateTranslationAnimationDuration(int distancePx, int minDuration) {
55        RecentsConfiguration config = RecentsConfiguration.getInstance();
56        return Math.max(minDuration, (int) (1000f /* ms/s */ *
57                (Math.abs(distancePx) / config.animationPxMovementPerSecond)));
58    }
59
60    /** Scales a rect about its centroid */
61    public static void scaleRectAboutCenter(Rect r, float scale) {
62        if (scale != 1.0f) {
63            int cx = r.centerX();
64            int cy = r.centerY();
65            r.offset(-cx, -cy);
66            r.left = (int) (r.left * scale + 0.5f);
67            r.top = (int) (r.top * scale + 0.5f);
68            r.right = (int) (r.right * scale + 0.5f);
69            r.bottom = (int) (r.bottom * scale + 0.5f);
70            r.offset(cx, cy);
71        }
72    }
73
74    /** Maps a coorindate in a descendant view into the parent. */
75    public static float mapCoordInDescendentToSelf(View descendant, View root,
76            float[] coord, boolean includeRootScroll) {
77        ArrayList<View> ancestorChain = new ArrayList<View>();
78
79        float[] pt = {coord[0], coord[1]};
80
81        View v = descendant;
82        while(v != root && v != null) {
83            ancestorChain.add(v);
84            v = (View) v.getParent();
85        }
86        ancestorChain.add(root);
87
88        float scale = 1.0f;
89        int count = ancestorChain.size();
90        for (int i = 0; i < count; i++) {
91            View v0 = ancestorChain.get(i);
92            // For TextViews, scroll has a meaning which relates to the text position
93            // which is very strange... ignore the scroll.
94            if (v0 != descendant || includeRootScroll) {
95                pt[0] -= v0.getScrollX();
96                pt[1] -= v0.getScrollY();
97            }
98
99            v0.getMatrix().mapPoints(pt);
100            pt[0] += v0.getLeft();
101            pt[1] += v0.getTop();
102            scale *= v0.getScaleX();
103        }
104
105        coord[0] = pt[0];
106        coord[1] = pt[1];
107        return scale;
108    }
109
110    /** Maps a coordinate in the root to a descendent. */
111    public static float mapCoordInSelfToDescendent(View descendant, View root,
112            float[] coord, Matrix tmpInverseMatrix) {
113        ArrayList<View> ancestorChain = new ArrayList<View>();
114
115        float[] pt = {coord[0], coord[1]};
116
117        View v = descendant;
118        while(v != root) {
119            ancestorChain.add(v);
120            v = (View) v.getParent();
121        }
122        ancestorChain.add(root);
123
124        float scale = 1.0f;
125        int count = ancestorChain.size();
126        tmpInverseMatrix.set(Matrix.IDENTITY_MATRIX);
127        for (int i = count - 1; i >= 0; i--) {
128            View ancestor = ancestorChain.get(i);
129            View next = i > 0 ? ancestorChain.get(i-1) : null;
130
131            pt[0] += ancestor.getScrollX();
132            pt[1] += ancestor.getScrollY();
133
134            if (next != null) {
135                pt[0] -= next.getLeft();
136                pt[1] -= next.getTop();
137                next.getMatrix().invert(tmpInverseMatrix);
138                tmpInverseMatrix.mapPoints(pt);
139                scale *= next.getScaleX();
140            }
141        }
142
143        coord[0] = pt[0];
144        coord[1] = pt[1];
145        return scale;
146    }
147
148    /** Calculates the constrast between two colors, using the algorithm provided by the WCAG v2. */
149    public static float computeContrastBetweenColors(int bg, int fg) {
150        float bgR = Color.red(bg) / 255f;
151        float bgG = Color.green(bg) / 255f;
152        float bgB = Color.blue(bg) / 255f;
153        bgR = (bgR < 0.03928f) ? bgR / 12.92f : (float) Math.pow((bgR + 0.055f) / 1.055f, 2.4f);
154        bgG = (bgG < 0.03928f) ? bgG / 12.92f : (float) Math.pow((bgG + 0.055f) / 1.055f, 2.4f);
155        bgB = (bgB < 0.03928f) ? bgB / 12.92f : (float) Math.pow((bgB + 0.055f) / 1.055f, 2.4f);
156        float bgL = 0.2126f * bgR + 0.7152f * bgG + 0.0722f * bgB;
157
158        float fgR = Color.red(fg) / 255f;
159        float fgG = Color.green(fg) / 255f;
160        float fgB = Color.blue(fg) / 255f;
161        fgR = (fgR < 0.03928f) ? fgR / 12.92f : (float) Math.pow((fgR + 0.055f) / 1.055f, 2.4f);
162        fgG = (fgG < 0.03928f) ? fgG / 12.92f : (float) Math.pow((fgG + 0.055f) / 1.055f, 2.4f);
163        fgB = (fgB < 0.03928f) ? fgB / 12.92f : (float) Math.pow((fgB + 0.055f) / 1.055f, 2.4f);
164        float fgL = 0.2126f * fgR + 0.7152f * fgG + 0.0722f * fgB;
165
166        return Math.abs((fgL + 0.05f) / (bgL + 0.05f));
167    }
168
169    /** Returns the base color overlaid with another overlay color with a specified alpha. */
170    public static int getColorWithOverlay(int baseColor, int overlayColor, float overlayAlpha) {
171        return Color.rgb(
172            (int) (overlayAlpha * Color.red(baseColor) +
173                    (1f - overlayAlpha) * Color.red(overlayColor)),
174            (int) (overlayAlpha * Color.green(baseColor) +
175                    (1f - overlayAlpha) * Color.green(overlayColor)),
176            (int) (overlayAlpha * Color.blue(baseColor) +
177                    (1f - overlayAlpha) * Color.blue(overlayColor)));
178    }
179
180    /** Sets some private shadow properties. */
181    public static void setShadowProperty(String property, String value)
182            throws IllegalAccessException, InvocationTargetException {
183        sPropertyMethod.invoke(null, property, value);
184    }
185
186    /**
187     * Cancels an animation ensuring that if it has listeners, onCancel and onEnd
188     * are not called.
189     */
190    public static void cancelAnimationWithoutCallbacks(Animator animator) {
191        if (animator != null) {
192            animator.removeAllListeners();
193            animator.cancel();
194        }
195    }
196}
197