protected AbstractJClass getMethodReturnClass(Element element, RestHolder holder) { ExecutableElement executableElement = (ExecutableElement) element; return codeModelHelper.typeMirrorToJClass(executableElement.getReturnType()); }
public void copyNonAAAnnotations(IJAnnotatable annotatable, List<? extends AnnotationMirror> annotationMirrors) { for (AnnotationMirror annotationMirror : annotationMirrors) { if (annotationMirror.getAnnotationType().asElement().getAnnotation(Inherited.class) == null) { AbstractJClass annotationClass = typeMirrorToJClass(annotationMirror.getAnnotationType()); if (!environment.isAndroidAnnotation(annotationClass.fullName()) && !IGNORED_ANNOTATIONS.contains(annotationClass.fullName())) { copyAnnotation(annotatable, annotationMirror); } } } }
@Override public void process(Element element, EComponentHolder holder) throws Exception { if (!annotationHelper.enclosingElementHasEnhancedComponentAnnotation(element)) { // do nothing when otto annotations are used in non-enhanced classes return; } ExecutableElement executableElement = (ExecutableElement) element; JMethod method = codeModelHelper.overrideAnnotatedMethod(executableElement, holder); addOttoAnnotation(executableElement, method); }
public void copyAnnotation(IJAnnotatable annotatable, AnnotationMirror annotationMirror) { Map<? extends ExecutableElement, ? extends AnnotationValue> parameters = annotationMirror.getElementValues(); if (!hasAnnotation(annotatable, annotationMirror) || annotatable instanceof JAnnotationArrayMember) { AbstractJClass annotation = typeMirrorToJClass(annotationMirror.getAnnotationType()); JAnnotationUse annotate = annotatable.annotate(annotation); for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> param : parameters.entrySet()) { param.getValue().accept(new AnnotationParamExtractor(annotate, this), param.getKey().getSimpleName().toString()); } } }
private void addParamToMethod(JMethod method, VariableElement parameter, int mod, Map<String, TypeMirror> actualTypes, boolean varParam) { String parameterName = parameter.getSimpleName().toString(); AbstractJClass parameterClass = typeMirrorToJClass(parameter.asType(), actualTypes); JVar param = varParam ? method.varParam(mod, parameterClass.elementType(), parameterName) : method.param(mod, parameterClass, parameterName); copyNonAAAnnotations(param, parameter.getAnnotationMirrors()); }
private void listenerFields(Element element, EActivityHolder holder) { List<TypeMirror> listenerTypeMirrors = extractListenerTypeMirrors(element); int i = 1; for (TypeMirror listenerTypeMirror : listenerTypeMirrors) { AbstractJClass listenerClass = codeModelHelper.typeMirrorToJClass(listenerTypeMirror); JFieldVar listener = holder.getGeneratedClass().field(JMod.PRIVATE, listenerClass, "listener" + i + generationSuffix()); codeModelHelper.addSuppressWarnings(listener, "unused"); listener.annotate(getJClass(RoboGuiceClasses.INJECT)); i++; } }
@Override public void process(Element element, EFragmentHolder holder) throws Exception { ExecutableElement executableElement = (ExecutableElement) element; JMethod delegatingMethod = codeModelHelper.overrideAnnotatedMethod(executableElement, holder); JBlock previousMethodBody = codeModelHelper.removeBody(delegatingMethod); IgnoreWhen ignoreWhen = element.getAnnotation(IgnoreWhen.class); JBlock methodBody = delegatingMethod.body(); JConditional conditional = null; switch (ignoreWhen.value()) { case VIEW_DESTROYED: conditional = methodBody._if(holder.getViewDestroyedField().not()); break; case DETACHED: conditional = methodBody._if(invoke(holder.getGeneratedClass().staticRef("this"), "getActivity").ne(_null())); break; } conditional._then().add(previousMethodBody); } }
@Override public void process(Element element, EComponentHolder holder) throws Exception { ExecutableElement executableElement = (ExecutableElement) element; JMethod delegatingMethod = codeModelHelper.overrideAnnotatedMethod(executableElement, holder); JBlock previousBody = codeModelHelper.removeBody(delegatingMethod); JDefinedClass anonymousRunnableClass = codeModelHelper.createDelegatingAnonymousRunnableClass(previousBody); UiThread annotation = element.getAnnotation(UiThread.class); long delay = annotation.delay(); UiThread.Propagation propagation = annotation.propagation(); if (delay == 0 && propagation == UiThread.Propagation.REUSE) { // Put in the check for the UI thread. addUIThreadCheck(delegatingMethod, previousBody, holder); } delegatingMethod.body().add(getJClass(UiThreadExecutor.class).staticInvoke(METHOD_RUN_TASK) // .arg(annotation.id()) // .arg(_new(anonymousRunnableClass)) // .arg(lit(delay))); }
int level = executableElement.getAnnotation(Trace.class).level(); JMethod method = codeModelHelper.overrideAnnotatedMethod(executableElement, holder); JBlock previousMethodBody = codeModelHelper.removeBody(method); tryBlock.body().add(previousMethodBody); } else { JInvocation superCall = codeModelHelper.getSuperCall(holder, method); result = thenBody.decl(getJClass(Object.class), "traceResult" + generationSuffix(), JExpr._null()); tryBlock = thenBody._try();
private void setPermissionMethods(Element element, EComponentHolder holder, AbstractJClass delegateClass, JFieldVar dispatcherCalledField) { ExecutableElement executableElement = (ExecutableElement) element; JMethod overrideMethod = codeModelHelper.overrideAnnotatedMethod(executableElement, holder); JBlock previousMethodBody = codeModelHelper.removeBody(overrideMethod); JBlock overrideMethodBody = overrideMethod.body(); JConditional conditional = overrideMethodBody._if(dispatcherCalledField.not()); JBlock thenBlock = conditional._then(); thenBlock.assign(dispatcherCalledField, JExpr.TRUE); String delegateMethodName = element.getSimpleName().toString() + "WithPermissionCheck"; JInvocation delegateCall = delegateClass.staticInvoke(delegateMethodName) .arg(JExpr._this()); overrideMethod.params().forEach(delegateCall::arg); if (overrideMethod.hasVarArgs()) { JVar jVar = overrideMethod.varParam(); if (jVar != null) { delegateCall.arg(jVar); } } if (!removeRuntimePermissionsAnnotation(holder.getGeneratedClass())) { codeModelHelper.copyAnnotation(overrideMethod, findAnnotation(element)); } thenBlock.add(delegateCall); JBlock elseBlock = conditional._else(); elseBlock.assign(dispatcherCalledField, JExpr.FALSE); elseBlock.add(previousMethodBody); }
public JMethod implementMethod(GeneratedClassHolder holder, List<ExecutableElement> methods, String methodName, String returnType, String... parameterTypes) { return implementMethod(holder, methods, methodName, returnType, false, parameterTypes); }
@Override public void assignValue(JBlock targetBlock, IJAssignmentTarget fieldRef, EActivityHolder holder, Element element, Element param) { String fieldName = element.getSimpleName().toString(); String extraKey = extractExtraKey(element, fieldName); TypeMirror actualType = codeModelHelper.getActualTypeOfEnclosingElementOfInjectedElement(holder, param); BundleHelper bundleHelper = new BundleHelper(getEnvironment(), actualType); JFieldVar extraKeyStaticField = getOrCreateStaticExtraField(holder, extraKey, fieldName); if (element.getKind() != ElementKind.PARAMETER) { holder.getIntentBuilder().getPutExtraMethod(element, new IntentBuilder.IntentExtra(param.asType(), fieldName, extraKeyStaticField)); } AbstractJClass elementClass = codeModelHelper.typeMirrorToJClass(param.asType()); JMethod injectExtrasMethod = holder.getInjectExtrasMethod(); JVar extras = holder.getInjectExtras(); IJExpression restoreMethodCall = bundleHelper.getExpressionToRestoreFromBundle(elementClass, extras, extraKeyStaticField, injectExtrasMethod); JBlock ifContainsKey = targetBlock._if(JExpr.invoke(extras, "containsKey").arg(extraKeyStaticField))._then(); ifContainsKey.assign(fieldRef, restoreMethodCall); }
private void addActionToIntentBuilder(EIntentServiceHolder holder, ExecutableElement executableElement, String methodName, JFieldVar actionKeyField) { JMethod method = holder.getIntentBuilderClass().method(PUBLIC, holder.getIntentBuilderClass(), methodName); JBlock body = method.body(); String docComment = getProcessingEnvironment().getElementUtils().getDocComment(executableElement); codeModelHelper.addTrimmedDocComment(method, docComment); method.javadoc().addReturn().append("the IntentBuilder to chain calls"); // setAction body.invoke("action").arg(actionKeyField); for (VariableElement param : executableElement.getParameters()) { String paramName = param.getSimpleName().toString(); AbstractJClass parameterClass = codeModelHelper.typeMirrorToJClass(param.asType()); JFieldVar paramVar = getStaticExtraField(holder, paramName); JVar methodParam = method.param(parameterClass, paramName); JInvocation putExtraInvocation = holder.getIntentBuilder().getSuperPutExtraInvocation(param.asType(), methodParam, paramVar); body.add(putExtraInvocation); } body._return(JExpr._this()); }
public void createBuilderInjectMethod(EFragmentHolder holder, Element element, List<ArgHelper> argHelpers) { JDefinedClass builderClass = holder.getBuilderClass(); JFieldRef builderArgsField = holder.getBuilderArgsField(); JMethod builderMethod = builderClass.method(PUBLIC, holder.narrow(builderClass), element.getSimpleName().toString()); String docComment = getProcessingEnvironment().getElementUtils().getDocComment(element); codeModelHelper.addTrimmedDocComment(builderMethod, docComment); for (ArgHelper argHelper : argHelpers) { String fieldName = argHelper.param.getSimpleName().toString(); TypeMirror actualType = codeModelHelper.getActualTypeOfEnclosingElementOfInjectedElement(holder, argHelper.param); BundleHelper bundleHelper = new BundleHelper(getEnvironment(), actualType); JFieldVar argKeyStaticField = getOrCreateStaticArgField(holder, argHelper.argKey, fieldName); AbstractJClass paramClass = codeModelHelper.typeMirrorToJClass(actualType); JVar arg = builderMethod.param(paramClass, fieldName); builderMethod.body().add(bundleHelper.getExpressionToSaveFromField(builderArgsField, argKeyStaticField, arg)); builderMethod.javadoc().addParam(fieldName).append("value for this Fragment argument"); } builderMethod.javadoc().addReturn().append("the FragmentBuilder to chain calls"); builderMethod.body()._return(_this()); }
public RestAnnotationHelper(AndroidAnnotationsEnvironment environment, String annotationName) { super(environment, annotationName); codeModelHelper = new APTCodeModelHelper(environment); }
@Override public void process(Element element, HasInstanceState holder) { AbstractJClass elementClass = codeModelHelper.typeMirrorToJClass(element.asType()); String fieldName = element.getSimpleName().toString(); JBlock saveStateBody = holder.getSaveStateMethodBody(); JVar saveStateBundleParam = holder.getSaveStateBundleParam(); JMethod restoreStateMethod = holder.getRestoreStateMethod(); JBlock restoreStateBody = holder.getRestoreStateMethodBody(); JVar restoreStateBundleParam = holder.getRestoreStateBundleParam(); TypeMirror type = codeModelHelper.getActualType(element, holder); BundleHelper bundleHelper = new BundleHelper(getEnvironment(), type); JFieldRef ref = ref(fieldName); saveStateBody.add(bundleHelper.getExpressionToSaveFromField(saveStateBundleParam, JExpr.lit(fieldName), ref)); IJExpression restoreMethodCall = bundleHelper.getExpressionToRestoreFromBundle(elementClass, restoreStateBundleParam, JExpr.lit(fieldName), restoreStateMethod); restoreStateBody.assign(ref, restoreMethodCall); } }
@Override public Void visitAnnotation(AnnotationMirror a, JAnnotationArrayMember p) { helper.copyAnnotation(p, a); return null; } }
public void createFactoryMethod(boolean hasSingletonScope) { AbstractJClass narrowedGeneratedClass = codeModelHelper.narrowGeneratedClass(generatedClass, annotatedElement.asType()); JMethod factoryMethod = generatedClass.method(PUBLIC | STATIC, narrowedGeneratedClass, GET_INSTANCE_METHOD_NAME); codeModelHelper.generify(factoryMethod, annotatedElement); JVar factoryMethodContextParam = factoryMethod.param(getClasses().CONTEXT, "context"); JBlock factoryMethodBody = factoryMethod.body(); /* * Singletons are bound to the application context */ if (hasSingletonScope) { JFieldVar instanceField = generatedClass.field(PRIVATE | STATIC, generatedClass, "instance" + generationSuffix()); JBlock creationBlock = factoryMethodBody // ._if(instanceField.eq(_null())) // ._then(); JVar previousNotifier = viewNotifierHelper.replacePreviousNotifierWithNull(creationBlock); creationBlock.assign(instanceField, _new(narrowedGeneratedClass).arg(factoryMethodContextParam.invoke("getApplicationContext"))); creationBlock.invoke(instanceField, getInit()); viewNotifierHelper.resetPreviousNotifier(creationBlock, previousNotifier); factoryMethodBody._return(instanceField); } else { factoryMethodBody._return(_new(narrowedGeneratedClass).arg(factoryMethodContextParam)); } }
private void addSuppressWarning() { generatedClass.javadoc().append(SUPPRESS_WARNING_COMMENT); codeModelHelper.addSuppressWarnings(getGeneratedClass(), "unused"); }
public JBlock removeBody(JMethod method) { JBlock body = method.body(); try { Field bodyField = JMethod.class.getDeclaredField("m_aBody"); bodyField.setAccessible(true); bodyField.set(method, null); } catch (Exception e) { throw new RuntimeException(e); } JBlock clonedBody = new JBlock().bracesRequired(false).indentRequired(false); copy(body, clonedBody); return clonedBody; }