a.java 源代码

package com.apm.insight.h;

import android.util.Log;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

public class a {

    private static final Map<Class<?>, Class<?>> f6490a;

    public static class C0100a<T> {

        public final Class<? extends T> f6491a;

        public final T f6492b;
    }

    static {
        HashMap hashMap = new HashMap();
        f6490a = hashMap;
        Class cls = Boolean.TYPE;
        hashMap.put(Boolean.class, cls);
        hashMap.put(Byte.class, Byte.TYPE);
        hashMap.put(Character.class, Character.TYPE);
        hashMap.put(Short.class, Short.TYPE);
        Class cls2 = Integer.TYPE;
        hashMap.put(Integer.class, cls2);
        Class cls3 = Float.TYPE;
        hashMap.put(Float.class, cls3);
        Class cls4 = Long.TYPE;
        hashMap.put(Long.class, cls4);
        hashMap.put(Double.class, Double.TYPE);
        hashMap.put(cls, cls);
        Class cls5 = Byte.TYPE;
        hashMap.put(cls5, cls5);
        Class cls6 = Character.TYPE;
        hashMap.put(cls6, cls6);
        Class cls7 = Short.TYPE;
        hashMap.put(cls7, cls7);
        hashMap.put(cls2, cls2);
        hashMap.put(cls3, cls3);
        hashMap.put(cls4, cls4);
        Class cls8 = Double.TYPE;
        hashMap.put(cls8, cls8);
    }

    public static <T> T a(Class<?> cls, String str, Object... objArr) {
        return (T) a(cls, str, a(objArr)).invoke(null, b(objArr));
    }

    private static Object[] b(Object... objArr) {
        if (objArr != null && objArr.length > 0) {
            Object[] objArr2 = new Object[objArr.length];
            for (int i6 = 0; i6 < objArr.length; i6++) {
                Object obj = objArr[i6];
                if (obj != null && (obj instanceof C0100a)) {
                    objArr2[i6] = ((C0100a) obj).f6492b;
                } else {
                    objArr2[i6] = obj;
                }
            }
            return objArr2;
        }
        return null;
    }

    public static <T> T a(String str, String str2, Object... objArr) {
        try {
            return (T) a(Class.forName(str), str2, objArr);
        } catch (Exception e6) {
            Log.w("JavaCalls", "Meet exception when call Method '" + str2 + "' in " + str, e6);
            return null;
        }
    }

    private static Method a(Class<?> cls, String str, Class<?>... clsArr) {
        Method a7 = a(cls.getDeclaredMethods(), str, clsArr);
        if (a7 != null) {
            a7.setAccessible(true);
            return a7;
        }
        if (cls.getSuperclass() != null) {
            return a((Class<?>) cls.getSuperclass(), str, clsArr);
        }
        throw new NoSuchMethodException();
    }

    private static Method a(Method[] methodArr, String str, Class<?>[] clsArr) {
        if (str == null) {
            throw new NullPointerException("Method name must not be null.");
        }
        for (Method method : methodArr) {
            if (method.getName().equals(str) && a(method.getParameterTypes(), clsArr)) {
                return method;
            }
        }
        return null;
    }

    private static boolean a(Class<?>[] clsArr, Class<?>[] clsArr2) {
        if (clsArr == null) {
            return clsArr2 == null || clsArr2.length == 0;
        }
        if (clsArr2 == null) {
            return clsArr.length == 0;
        }
        if (clsArr.length != clsArr2.length) {
            return false;
        }
        for (int i6 = 0; i6 < clsArr.length; i6++) {
            if (!clsArr[i6].isAssignableFrom(clsArr2[i6])) {
                Map<Class<?>, Class<?>> map = f6490a;
                if (!map.containsKey(clsArr[i6]) || !map.get(clsArr[i6]).equals(map.get(clsArr2[i6]))) {
                    return false;
                }
            }
        }
        return true;
    }

    private static Class<?>[] a(Object... objArr) {
        if (objArr == null || objArr.length <= 0) {
            return null;
        }
        Class<?>[] clsArr = new Class[objArr.length];
        for (int i6 = 0; i6 < objArr.length; i6++) {
            Object obj = objArr[i6];
            if (obj == null || !(obj instanceof C0100a)) {
                clsArr[i6] = obj == null ? null : obj.getClass();
            } else {
                clsArr[i6] = ((C0100a) obj).f6491a;
            }
        }
        return clsArr;
    }
}