Beispiel #1
0
 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);
     }
   }
 }
Beispiel #2
0
 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);
 }