public void callValidator(final AQuery $, final Ajax ajax) throws VolleyError {
Map<Annotation, java.lang.reflect.Method> method =
ReflectUtils.getMethodsByAnnotation(Handler.class, getClass());
for (Map.Entry<Annotation, java.lang.reflect.Method> entry : method.entrySet()) {
try {
entry
.getValue()
.invoke(
this,
ReflectUtils.fillParamsByAnnotations(
entry.getValue(),
new ReflectUtils.ParamInjector() {
@Override
public Object onInject(
Class paramType, List<? extends Annotation> annotations, int position) {
try {
return scanAnnotation($, paramType, annotations.get(0), ajax);
} catch (Exception e) {
$.log.i(e);
return null;
}
}
}));
} catch (InvocationTargetException e) {
if (e.getTargetException() instanceof VolleyError) {
throw ((VolleyError) e.getTargetException());
}
$.log.i(e.getTargetException());
} catch (Exception e) {
$.log.i(e);
}
}
}
public void callModelValidator(final AQuery $, final Ajax ajax) throws VolleyError {
Map<Annotation, java.lang.reflect.Method> methodMap =
ReflectUtils.getMethodsByAnnotation(Handler.class, getClass());
for (Map.Entry<Annotation, java.lang.reflect.Method> entry : methodMap.entrySet()) {
java.lang.reflect.Method method = entry.getValue();
for (int i = 0; i < method.getParameterTypes().length; i++) {
Class type = method.getParameterTypes()[i];
if (method.getParameterAnnotations()[i][0] instanceof ResponseBody
&& type != String.class
&& type != byte[].class
&& Checker.class.isAssignableFrom(type)) {
try {
Checker checker =
(Checker) new Gson().fromJson(new String(ajax.getResponseBody(), "utf-8"), type);
if (checker.getValidator().validate()) {
$.log.i("has warning");
}
} catch (UnsupportedEncodingException e) {
$.log.i(e);
throw new IllegalDataError("Unsupported encoding bytes");
}
}
}
}
}
protected Object firstInstance(Class type) {
return ((MethodDelegate) ReflectUtils.newInstance(type)).newInstance(target);
}
public void generateClass(ClassVisitor v) throws NoSuchMethodException {
Method proxy = ReflectUtils.findInterfaceMethod(iface);
final Method method = targetClass.getMethod(methodName, proxy.getParameterTypes());
if (!proxy.getReturnType().isAssignableFrom(method.getReturnType())) {
throw new IllegalArgumentException("incompatible return types");
}
MethodInfo methodInfo = ReflectUtils.getMethodInfo(method);
boolean isStatic = TypeUtils.isStatic(methodInfo.getModifiers());
if ((target == null) ^ isStatic) {
throw new IllegalArgumentException(
"Static method " + (isStatic ? "not " : "") + "expected");
}
ClassEmitter ce = new ClassEmitter(v);
CodeEmitter e;
ce.begin_class(
Constants.V1_2,
Constants.ACC_PUBLIC,
getClassName(),
METHOD_DELEGATE,
new Type[] {Type.getType(iface)},
Constants.SOURCE_FILE);
ce.declare_field(Constants.PRIVATE_FINAL_STATIC, "eqMethod", Constants.TYPE_STRING, null);
EmitUtils.null_constructor(ce);
// generate proxied method
MethodInfo proxied = ReflectUtils.getMethodInfo(iface.getDeclaredMethods()[0]);
int modifiers = Constants.ACC_PUBLIC;
if ((proxied.getModifiers() & Constants.ACC_VARARGS) == Constants.ACC_VARARGS) {
modifiers |= Constants.ACC_VARARGS;
}
e = EmitUtils.begin_method(ce, proxied, modifiers);
e.load_this();
e.super_getfield("target", Constants.TYPE_OBJECT);
e.checkcast(methodInfo.getClassInfo().getType());
e.load_args();
e.invoke(methodInfo);
e.return_value();
e.end_method();
// newInstance
e = ce.begin_method(Constants.ACC_PUBLIC, NEW_INSTANCE, null);
e.new_instance_this();
e.dup();
e.dup2();
e.invoke_constructor_this();
e.getfield("eqMethod");
e.super_putfield("eqMethod", Constants.TYPE_STRING);
e.load_arg(0);
e.super_putfield("target", Constants.TYPE_OBJECT);
e.return_value();
e.end_method();
// static initializer
e = ce.begin_static();
e.push(methodInfo.getSignature().toString());
e.putfield("eqMethod");
e.return_value();
e.end_method();
ce.end_class();
}
protected ProtectionDomain getProtectionDomain() {
return ReflectUtils.getProtectionDomain(targetClass);
}