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
17package android.animation;
18
19import com.android.layoutlib.bridge.Bridge;
20import com.android.layoutlib.bridge.impl.DelegateManager;
21import com.android.tools.layoutlib.annotations.LayoutlibDelegate;
22
23import java.lang.reflect.InvocationTargetException;
24import java.lang.reflect.Method;
25import java.util.Arrays;
26import java.util.HashMap;
27import java.util.Map;
28
29/**
30 * Delegate implementing the native methods of android.animation.PropertyValuesHolder
31 *
32 * Through the layoutlib_create tool, the original native methods of PropertyValuesHolder have been
33 * replaced by calls to methods of the same name in this delegate class.
34 *
35 * Because it's a stateless class to start with, there's no need to keep a {@link DelegateManager}
36 * around to map int to instance of the delegate.
37 *
38 * The main goal of this class' methods are to provide a native way to access setters and getters
39 * on some object. We override these methods to use reflection since the original reflection
40 * implementation of the PropertyValuesHolder won't be able to access protected methods.
41 *
42 */
43/*package*/
44@SuppressWarnings("unused")
45class PropertyValuesHolder_Delegate {
46    // This code is copied from android.animation.PropertyValuesHolder and must be kept in sync
47    // We try several different types when searching for appropriate setter/getter functions.
48    // The caller may have supplied values in a type that does not match the setter/getter
49    // functions (such as the integers 0 and 1 to represent floating point values for alpha).
50    // Also, the use of generics in constructors means that we end up with the Object versions
51    // of primitive types (Float vs. float). But most likely, the setter/getter functions
52    // will take primitive types instead.
53    // So we supply an ordered array of other types to try before giving up.
54    private static Class[] FLOAT_VARIANTS = {float.class, Float.class, double.class, int.class,
55            Double.class, Integer.class};
56    private static Class[] INTEGER_VARIANTS = {int.class, Integer.class, float.class, double.class,
57            Float.class, Double.class};
58
59    private static final Object sMethodIndexLock = new Object();
60    private static final Map<Long, Method> ID_TO_METHOD = new HashMap<Long, Method>();
61    private static final Map<String, Long> METHOD_NAME_TO_ID = new HashMap<String, Long>();
62    private static long sNextId = 1;
63
64    private static long registerMethod(Class<?> targetClass, String methodName, Class[] types,
65            int nArgs) {
66        // Encode the number of arguments in the method name
67        String methodIndexName = String.format("%1$s.%2$s#%3$d", targetClass.getSimpleName(),
68                methodName, nArgs);
69        synchronized (sMethodIndexLock) {
70            Long methodId = METHOD_NAME_TO_ID.get(methodIndexName);
71
72            if (methodId != null) {
73                // The method was already registered
74                return methodId;
75            }
76
77            Class[] args = new Class[nArgs];
78            Method method = null;
79            for (Class typeVariant : types) {
80                for (int i = 0; i < nArgs; i++) {
81                    args[i] = typeVariant;
82                }
83                try {
84                    method = targetClass.getDeclaredMethod(methodName, args);
85                } catch (NoSuchMethodException ignore) {
86                }
87            }
88
89            if (method != null) {
90                methodId = sNextId++;
91                ID_TO_METHOD.put(methodId, method);
92                METHOD_NAME_TO_ID.put(methodIndexName, methodId);
93
94                return methodId;
95            }
96        }
97
98        // Method not found
99        return 0;
100    }
101
102    private static void callMethod(Object target, long methodID, Object... args) {
103        Method method = ID_TO_METHOD.get(methodID);
104        assert method != null;
105
106        try {
107            method.setAccessible(true);
108            method.invoke(target, args);
109        } catch (IllegalAccessException e) {
110            Bridge.getLog().error(null, "Unable to update property during animation", e, null);
111        } catch (InvocationTargetException e) {
112            Bridge.getLog().error(null, "Unable to update property during animation", e, null);
113        }
114    }
115
116    @LayoutlibDelegate
117    /*package*/ static long nGetIntMethod(Class<?> targetClass, String methodName) {
118        return nGetMultipleIntMethod(targetClass, methodName, 1);
119    }
120
121    @LayoutlibDelegate
122    /*package*/ static long nGetFloatMethod(Class<?> targetClass, String methodName) {
123        return nGetMultipleFloatMethod(targetClass, methodName, 1);
124    }
125
126    @LayoutlibDelegate
127    /*package*/ static long nGetMultipleIntMethod(Class<?> targetClass, String methodName,
128            int numParams) {
129        return registerMethod(targetClass, methodName, INTEGER_VARIANTS, numParams);
130    }
131
132    @LayoutlibDelegate
133    /*package*/ static long nGetMultipleFloatMethod(Class<?> targetClass, String methodName,
134            int numParams) {
135        return registerMethod(targetClass, methodName, FLOAT_VARIANTS, numParams);
136    }
137
138    @LayoutlibDelegate
139    /*package*/ static void nCallIntMethod(Object target, long methodID, int arg) {
140        callMethod(target, methodID, arg);
141    }
142
143    @LayoutlibDelegate
144    /*package*/ static void nCallFloatMethod(Object target, long methodID, float arg) {
145        callMethod(target, methodID, arg);
146    }
147
148    @LayoutlibDelegate
149    /*package*/ static void nCallTwoIntMethod(Object target, long methodID, int arg1,
150            int arg2) {
151        callMethod(target, methodID, arg1, arg2);
152    }
153
154    @LayoutlibDelegate
155    /*package*/ static void nCallFourIntMethod(Object target, long methodID, int arg1,
156            int arg2, int arg3, int arg4) {
157        callMethod(target, methodID, arg1, arg2, arg3, arg4);
158    }
159
160    @LayoutlibDelegate
161    /*package*/ static void nCallMultipleIntMethod(Object target, long methodID,
162            int[] args) {
163        assert args != null;
164
165        // Box parameters
166        Object[] params = new Object[args.length];
167        for (int i = 0; i < args.length; i++) {
168            params[i] = args;
169        }
170        callMethod(target, methodID, params);
171    }
172
173    @LayoutlibDelegate
174    /*package*/ static void nCallTwoFloatMethod(Object target, long methodID, float arg1,
175            float arg2) {
176        callMethod(target, methodID, arg1, arg2);
177    }
178
179    @LayoutlibDelegate
180    /*package*/ static void nCallFourFloatMethod(Object target, long methodID, float arg1,
181            float arg2, float arg3, float arg4) {
182        callMethod(target, methodID, arg1, arg2, arg3, arg4);
183    }
184
185    @LayoutlibDelegate
186    /*package*/ static void nCallMultipleFloatMethod(Object target, long methodID,
187            float[] args) {
188        assert args != null;
189
190        // Box parameters
191        Object[] params = new Object[args.length];
192        for (int i = 0; i < args.length; i++) {
193            params[i] = args;
194        }
195        callMethod(target, methodID, params);
196    }
197}
198