From 9193f63e1b41f548d973e34082bfad889c0fb391 Mon Sep 17 00:00:00 2001 From: naixx Date: Tue, 15 Jan 2013 01:16:43 +0300 Subject: [PATCH 1/5] Extract base listener processor to use with View.setOn***Listener --- .../helper/CanonicalNameConstants.java | 5 +- .../processing/AbstractListenerProcessor.java | 105 ++++++++++++++++++ .../processing/ClickProcessor.java | 72 +++++------- .../processing/EBeansHolder.java | 5 +- .../processing/LongClickProcessor.java | 86 ++++---------- .../processing/TouchProcessor.java | 88 +++++---------- 6 files changed, 189 insertions(+), 172 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AbstractListenerProcessor.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/CanonicalNameConstants.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/CanonicalNameConstants.java index df038444fb..93c00df8d6 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/CanonicalNameConstants.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/CanonicalNameConstants.java @@ -50,6 +50,9 @@ public final class CanonicalNameConstants { public static final String TEXT_VIEW = "android.widget.TextView"; public static final String VIEW = "android.view.View"; public static final String VIEW_ON_CLICK_LISTENER = "android.view.View.OnClickListener"; + public static final String VIEW_ON_TOUCH_LISTENER = "android.view.View.OnTouchListener"; + public static final String VIEW_ON_LONG_CLICK_LISTENER = "android.view.View.OnLongClickListener"; + public static final String VIEW_ON_FOCUS_CHANGE_LISTENER = "android.view.View.OnFocusChangeListener"; public static final String VIEW_GROUP_LAYOUT_PARAMS = "android.view.ViewGroup.LayoutParams"; public static final String VIEW_GROUP = "android.view.ViewGroup"; public static final String CONTEXT = "android.content.Context"; @@ -64,7 +67,6 @@ public final class CanonicalNameConstants { public static final String ON_ITEM_CLICK_LISTENER = "android.widget.AdapterView.OnItemClickListener"; public static final String ON_ITEM_LONG_CLICK_LISTENER = "android.widget.AdapterView.OnItemLongClickListener"; public static final String ON_ITEM_SELECTED_LISTENER = "android.widget.AdapterView.OnItemSelectedListener"; - public static final String ON_LONG_CLICK_LISTENER = "android.view.View.OnLongClickListener"; public static final String WINDOW = "android.view.Window"; public static final String MENU_ITEM = "android.view.MenuItem"; public static final String MENU_INFLATER = "android.view.MenuInflater"; @@ -74,7 +76,6 @@ public final class CanonicalNameConstants { public static final String RESOURCES = "android.content.res.Resources"; public static final String CONFIGURATION = "android.content.res.Configuration"; public static final String MOTION_EVENT = "android.view.MotionEvent"; - public static final String ON_TOUCH_LISTENER = "android.view.View.OnTouchListener"; public static final String HANDLER = "android.os.Handler"; public static final String SERVICE = "android.app.Service"; public static final String BROADCAST_RECEIVER = "android.content.BroadcastReceiver"; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AbstractListenerProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AbstractListenerProcessor.java new file mode 100644 index 0000000000..1b7f731353 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AbstractListenerProcessor.java @@ -0,0 +1,105 @@ +/** + * Copyright (C) 2010-2012 eBusiness Information, Excilys Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed To in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package org.androidannotations.processing; + +import static com.sun.codemodel.JExpr._new; +import static com.sun.codemodel.JExpr._null; +import static com.sun.codemodel.JExpr.invoke; + +import java.util.List; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.TypeMirror; + +import org.androidannotations.helper.IdAnnotationHelper; +import org.androidannotations.processing.EBeansHolder.Classes; +import org.androidannotations.rclass.IRClass; +import org.androidannotations.rclass.IRClass.Res; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JCodeModel; +import com.sun.codemodel.JDefinedClass; +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JFieldRef; +import com.sun.codemodel.JInvocation; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JVar; + +/** + * @author Pierre-Yves Ricau + * @author Mathieu Boniface + * @author Rostislav Chekan + */ +public abstract class AbstractListenerProcessor implements DecoratingElementProcessor { + + private IdAnnotationHelper helper; + protected Classes classes; + protected JCodeModel codeModel; + + public AbstractListenerProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { + helper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); + } + + @Override + public void process(Element element, JCodeModel jcodeModel, EBeanHolder holder) { + classes = holder.classes(); + codeModel = jcodeModel; + + String methodName = element.getSimpleName().toString(); + + ExecutableElement executableElement = (ExecutableElement) element; + List parameters = executableElement.getParameters(); + TypeMirror returnType = executableElement.getReturnType(); + + List idsRefs = helper.extractAnnotationFieldRefs(holder, element, Res.ID, true); + + JDefinedClass listenerAnonymousClass = codeModel.anonymousClass(getListenerClass()); + JMethod listenerMethod = createListenerMethod(listenerAnonymousClass); + listenerMethod.annotate(Override.class); + + JBlock listenerMethodBody = listenerMethod.body(); + + JExpression activityRef = holder.generatedClass.staticRef("this"); + JInvocation call = invoke(activityRef, methodName); + + makeCall(listenerMethodBody, call, returnType); + + processParameters(listenerMethod, call, parameters); + + for (JFieldRef idRef : idsRefs) { + JBlock block = holder.afterSetContentView.body().block(); + JInvocation findViewById = invoke("findViewById"); + + JVar view = block.decl(classes.VIEW, "view", findViewById.arg(idRef)); + block._if(view.ne(_null()))._then().invoke(view, getSetterName()).arg(_new(listenerAnonymousClass)); + } + } + + protected abstract void makeCall(JBlock listenerMethodBody, JInvocation call, TypeMirror returnType); + + protected abstract void processParameters(JMethod listenerMethod, JInvocation call, List userParameters); + + protected abstract JMethod createListenerMethod(JDefinedClass listenerAnonymousClass); + + protected abstract String getSetterName(); + + protected abstract JClass getListenerClass(); + +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ClickProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ClickProcessor.java index 8874a00705..d0a3971179 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ClickProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ClickProcessor.java @@ -15,45 +15,31 @@ */ package org.androidannotations.processing; -import static com.sun.codemodel.JExpr._new; -import static com.sun.codemodel.JExpr._null; -import static com.sun.codemodel.JExpr.invoke; - import java.lang.annotation.Annotation; import java.util.List; import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; import javax.lang.model.element.VariableElement; +import javax.lang.model.type.TypeMirror; import org.androidannotations.annotations.Click; -import org.androidannotations.helper.AnnotationHelper; -import org.androidannotations.processing.EBeansHolder.Classes; import org.androidannotations.rclass.IRClass; -import org.androidannotations.rclass.IRClass.Res; + import com.sun.codemodel.JBlock; -import com.sun.codemodel.JCodeModel; +import com.sun.codemodel.JClass; import com.sun.codemodel.JDefinedClass; -import com.sun.codemodel.JExpression; -import com.sun.codemodel.JFieldRef; import com.sun.codemodel.JInvocation; import com.sun.codemodel.JMethod; import com.sun.codemodel.JMod; import com.sun.codemodel.JVar; /** - * @author Mathieu Boniface - * @author Pierre-Yves + * @author Rostislav Chekan */ -public class ClickProcessor implements DecoratingElementProcessor { - - private final AnnotationHelper helper; - private final IRClass rClass; +public class ClickProcessor extends AbstractListenerProcessor { public ClickProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - this.rClass = rClass; - helper = new AnnotationHelper(processingEnv); + super(processingEnv, rClass); } @Override @@ -62,38 +48,34 @@ public Class getTarget() { } @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - Classes classes = holder.classes(); - - String methodName = element.getSimpleName().toString(); - - ExecutableElement executableElement = (ExecutableElement) element; - List parameters = executableElement.getParameters(); - - boolean hasViewParameter = parameters.size() == 1; - - List idsRefs = helper.extractAnnotationFieldRefs(holder, element, getTarget(), rClass.get(Res.ID), true); + protected void makeCall(JBlock listenerMethodBody, JInvocation call, TypeMirror returnType) { + listenerMethodBody.add(call); + } - JDefinedClass onClickListenerClass = codeModel.anonymousClass(classes.VIEW_ON_CLICK_LISTENER); - JMethod onClickMethod = onClickListenerClass.method(JMod.PUBLIC, codeModel.VOID, "onClick"); - onClickMethod.annotate(Override.class); - JVar onClickViewParam = onClickMethod.param(classes.VIEW, "view"); + @Override + protected void processParameters(JMethod listenerMethod, JInvocation call, List parameters) { + boolean hasItemParameter = parameters.size() == 1; - JExpression activityRef = holder.generatedClass.staticRef("this"); - JInvocation clickCall = onClickMethod.body().invoke(activityRef, methodName); + JVar viewParam = listenerMethod.param(classes.VIEW, "view"); - if (hasViewParameter) { - clickCall.arg(onClickViewParam); + if (hasItemParameter) { + call.arg(viewParam); } + } - for (JFieldRef idRef : idsRefs) { - JBlock block = holder.afterSetContentView.body().block(); + @Override + protected JMethod createListenerMethod(JDefinedClass listenerAnonymousClass) { + return listenerAnonymousClass.method(JMod.PUBLIC, codeModel.VOID, "onClick"); + } - JInvocation findViewById = invoke("findViewById"); - JVar view = block.decl(classes.VIEW, "view", findViewById.arg(idRef)); - block._if(view.ne(_null()))._then().invoke(view, "setOnClickListener").arg(_new(onClickListenerClass)); - } + @Override + protected String getSetterName() { + return "setOnClickListener"; + } + @Override + protected JClass getListenerClass() { + return classes.VIEW_ON_CLICK_LISTENER; } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EBeansHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EBeansHolder.java index 090d001e82..6bae8411f5 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EBeansHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EBeansHolder.java @@ -64,6 +64,9 @@ public class Classes { public final JClass TEXT_VIEW = refClass(CanonicalNameConstants.TEXT_VIEW); public final JClass VIEW = refClass(CanonicalNameConstants.VIEW); public final JClass VIEW_ON_CLICK_LISTENER = refClass(CanonicalNameConstants.VIEW_ON_CLICK_LISTENER); + public final JClass VIEW_ON_TOUCH_LISTENER = refClass(CanonicalNameConstants.VIEW_ON_TOUCH_LISTENER); + public final JClass VIEW_ON_LONG_CLICK_LISTENER = refClass(CanonicalNameConstants.VIEW_ON_LONG_CLICK_LISTENER); + public final JClass VIEW_ON_FOCUS_CHANGE_LISTENER = refClass(CanonicalNameConstants.VIEW_ON_FOCUS_CHANGE_LISTENER); public final JClass VIEW_GROUP_LAYOUT_PARAMS = refClass(CanonicalNameConstants.VIEW_GROUP_LAYOUT_PARAMS); public final JClass KEY_EVENT = refClass(CanonicalNameConstants.KEY_EVENT); public final JClass CONTEXT = refClass(CanonicalNameConstants.CONTEXT); @@ -79,7 +82,6 @@ public class Classes { public final JClass ON_ITEM_LONG_CLICK_LISTENER = refClass(CanonicalNameConstants.ON_ITEM_LONG_CLICK_LISTENER); public final JClass ON_ITEM_CLICK_LISTENER = refClass(CanonicalNameConstants.ON_ITEM_CLICK_LISTENER); public final JClass ON_ITEM_SELECTED_LISTENER = refClass(CanonicalNameConstants.ON_ITEM_SELECTED_LISTENER); - public final JClass ON_LONG_CLICK_LISTENER = refClass(CanonicalNameConstants.ON_LONG_CLICK_LISTENER); public final JClass WINDOW = refClass(CanonicalNameConstants.WINDOW); public final JClass MENU_ITEM = refClass(CanonicalNameConstants.MENU_ITEM); public final JClass MENU_INFLATER = refClass(CanonicalNameConstants.MENU_INFLATER); @@ -88,7 +90,6 @@ public class Classes { public final JClass RESOURCES = refClass(CanonicalNameConstants.RESOURCES); public final JClass CONFIGURATION = refClass(CanonicalNameConstants.CONFIGURATION); public final JClass MOTION_EVENT = refClass(CanonicalNameConstants.MOTION_EVENT); - public final JClass ON_TOUCH_LISTENER = refClass(CanonicalNameConstants.ON_TOUCH_LISTENER); public final JClass HANDLER = refClass(CanonicalNameConstants.HANDLER); public final JClass KEY_STORE = refClass(CanonicalNameConstants.KEY_STORE); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/LongClickProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/LongClickProcessor.java index f06a242edb..e67b657614 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/LongClickProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/LongClickProcessor.java @@ -1,57 +1,29 @@ -/** - * Copyright (C) 2010-2012 eBusiness Information, Excilys Group - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not - * use this file except in compliance with the License. You may obtain a copy of - * the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed To in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations under - * the License. - */ package org.androidannotations.processing; import java.lang.annotation.Annotation; import java.util.List; import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; import javax.lang.model.element.VariableElement; import javax.lang.model.type.TypeKind; import javax.lang.model.type.TypeMirror; import org.androidannotations.annotations.LongClick; -import org.androidannotations.helper.IdAnnotationHelper; -import org.androidannotations.processing.EBeansHolder.Classes; import org.androidannotations.rclass.IRClass; -import org.androidannotations.rclass.IRClass.Res; + import com.sun.codemodel.JBlock; -import com.sun.codemodel.JCodeModel; +import com.sun.codemodel.JClass; import com.sun.codemodel.JDefinedClass; import com.sun.codemodel.JExpr; -import com.sun.codemodel.JExpression; -import com.sun.codemodel.JFieldRef; import com.sun.codemodel.JInvocation; import com.sun.codemodel.JMethod; import com.sun.codemodel.JMod; import com.sun.codemodel.JVar; -/** - * @author Benjamin Fellous - * @author Pierre-Yves Ricau - * @author Mathieu Boniface - */ -public class LongClickProcessor implements DecoratingElementProcessor { - - private IdAnnotationHelper helper; +public class LongClickProcessor extends AbstractListenerProcessor { public LongClickProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - helper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); + super(processingEnv, rClass); } @Override @@ -60,48 +32,38 @@ public Class getTarget() { } @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - Classes classes = holder.classes(); - - String methodName = element.getSimpleName().toString(); - - ExecutableElement executableElement = (ExecutableElement) element; - List parameters = executableElement.getParameters(); - TypeMirror returnType = executableElement.getReturnType(); + protected void makeCall(JBlock listenerMethodBody, JInvocation call, TypeMirror returnType) { boolean returnMethodResult = returnType.getKind() != TypeKind.VOID; - - boolean hasItemParameter = parameters.size() == 1; - - List idsRefs = helper.extractAnnotationFieldRefs(holder, element, Res.ID, true); - - JDefinedClass listenerAnonymousClass = codeModel.anonymousClass(classes.ON_LONG_CLICK_LISTENER); - JMethod listenerMethod = listenerAnonymousClass.method(JMod.PUBLIC, codeModel.BOOLEAN, "onLongClick"); - listenerMethod.annotate(Override.class); - JVar viewParam = listenerMethod.param(classes.VIEW, "view"); - - JBlock listenerMethodBody = listenerMethod.body(); - - JExpression activityRef = holder.generatedClass.staticRef("this"); - JInvocation call = JExpr.invoke(activityRef, methodName); - if (returnMethodResult) { listenerMethodBody._return(call); } else { listenerMethodBody.add(call); listenerMethodBody._return(JExpr.TRUE); } + } - if (hasItemParameter) { + @Override + protected void processParameters(JMethod listenerMethod, JInvocation call, List parameters) { + boolean hasViewParameter = parameters.size() == 1; + JVar viewParam = listenerMethod.param(classes.VIEW, "view"); + if (hasViewParameter) { call.arg(viewParam); } + } - for (JFieldRef idRef : idsRefs) { - JBlock block = holder.afterSetContentView.body().block(); - JInvocation findViewById = JExpr.invoke("findViewById"); + @Override + protected JMethod createListenerMethod(JDefinedClass listenerAnonymousClass) { + return listenerAnonymousClass.method(JMod.PUBLIC, codeModel.BOOLEAN, "onLongClick"); + } - JVar view = block.decl(classes.VIEW, "view", findViewById.arg(idRef)); - block._if(view.ne(JExpr._null()))._then().invoke(view, "setOnLongClickListener").arg(JExpr._new(listenerAnonymousClass)); - } + @Override + protected String getSetterName() { + return "setOnLongClickListener"; + } + + @Override + protected JClass getListenerClass() { + return classes.VIEW_ON_LONG_CLICK_LISTENER; } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TouchProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TouchProcessor.java index 4866a07494..d9ca2cc9a6 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TouchProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TouchProcessor.java @@ -1,58 +1,33 @@ -/** - * Copyright (C) 2010-2012 eBusiness Information, Excilys Group - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not - * use this file except in compliance with the License. You may obtain a copy of - * the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed To in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations under - * the License. - */ package org.androidannotations.processing; -import static com.sun.codemodel.JExpr._new; -import static com.sun.codemodel.JExpr._null; - import java.lang.annotation.Annotation; import java.util.List; import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; import javax.lang.model.element.VariableElement; import javax.lang.model.type.TypeKind; import javax.lang.model.type.TypeMirror; import org.androidannotations.annotations.Touch; -import org.androidannotations.helper.IdAnnotationHelper; -import org.androidannotations.processing.EBeansHolder.Classes; import org.androidannotations.rclass.IRClass; -import org.androidannotations.rclass.IRClass.Res; + import com.sun.codemodel.JBlock; -import com.sun.codemodel.JCodeModel; +import com.sun.codemodel.JClass; import com.sun.codemodel.JDefinedClass; import com.sun.codemodel.JExpr; -import com.sun.codemodel.JFieldRef; import com.sun.codemodel.JInvocation; import com.sun.codemodel.JMethod; import com.sun.codemodel.JMod; import com.sun.codemodel.JVar; /** - * @author Pierre-Yves Ricau - * @author Mathieu Boniface + * @author Rostislav Chekan + * */ -public class TouchProcessor implements DecoratingElementProcessor { - - private IdAnnotationHelper helper; +public class TouchProcessor extends AbstractListenerProcessor { public TouchProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - helper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); + super(processingEnv, rClass); } @Override @@ -61,51 +36,42 @@ public Class getTarget() { } @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - Classes classes = holder.classes(); - - String methodName = element.getSimpleName().toString(); - - ExecutableElement executableElement = (ExecutableElement) element; - List parameters = executableElement.getParameters(); - TypeMirror returnType = executableElement.getReturnType(); + protected void makeCall(JBlock listenerMethodBody, JInvocation call, TypeMirror returnType) { boolean returnMethodResult = returnType.getKind() != TypeKind.VOID; - boolean hasItemParameter = parameters.size() == 2; - - List idsRefs = helper.extractAnnotationFieldRefs(holder, element, Res.ID, true); - - JDefinedClass listenerClass = codeModel.anonymousClass(classes.ON_TOUCH_LISTENER); - JMethod listenerMethod = listenerClass.method(JMod.PUBLIC, codeModel.BOOLEAN, "onTouch"); - listenerMethod.annotate(Override.class); - - JVar viewParam = listenerMethod.param(classes.VIEW, "view"); - JVar eventParam = listenerMethod.param(classes.MOTION_EVENT, "event"); - - JBlock listenerMethodBody = listenerMethod.body(); - - JInvocation call = JExpr.invoke(methodName); - if (returnMethodResult) { listenerMethodBody._return(call); } else { listenerMethodBody.add(call); listenerMethodBody._return(JExpr.TRUE); } + } - call.arg(eventParam); + @Override + protected void processParameters(JMethod listenerMethod, JInvocation call, List parameters) { + JVar viewParam = listenerMethod.param(classes.VIEW, "view"); + JVar eventParam = listenerMethod.param(classes.MOTION_EVENT, "event"); + boolean hasItemParameter = parameters.size() == 2; + call.arg(eventParam); if (hasItemParameter) { call.arg(viewParam); } + } - for (JFieldRef idRef : idsRefs) { - JBlock block = holder.afterSetContentView.body().block(); - JInvocation findViewById = JExpr.invoke("findViewById"); + @Override + protected JMethod createListenerMethod(JDefinedClass listenerAnonymousClass) { + return listenerAnonymousClass.method(JMod.PUBLIC, codeModel.BOOLEAN, "onTouch"); + } - JVar view = block.decl(classes.VIEW, "view", findViewById.arg(idRef)); - block._if(view.ne(_null()))._then().invoke(view, "setOnTouchListener").arg(_new(listenerClass)); - } + @Override + protected String getSetterName() { + return "setOnTouchListener"; + } + + @Override + protected JClass getListenerClass() { + return classes.VIEW_ON_TOUCH_LISTENER; } } From 381fb5b6418d4ad75693f940a61cc337deddb64a Mon Sep 17 00:00:00 2001 From: naixx Date: Tue, 15 Jan 2013 04:20:09 +0300 Subject: [PATCH 2/5] Add @FocusChange --- .../annotations/FocusChange.java | 18 +++++ .../AndroidAnnotationProcessor.java | 6 ++ .../processing/FocusChangeProcessor.java | 64 +++++++++++++++++ .../validation/FocusChangeValidator.java | 70 +++++++++++++++++++ 4 files changed, 158 insertions(+) create mode 100644 AndroidAnnotations/androidannotations-api/src/main/java/org/androidannotations/annotations/FocusChange.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FocusChangeProcessor.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FocusChangeValidator.java diff --git a/AndroidAnnotations/androidannotations-api/src/main/java/org/androidannotations/annotations/FocusChange.java b/AndroidAnnotations/androidannotations-api/src/main/java/org/androidannotations/annotations/FocusChange.java new file mode 100644 index 0000000000..ae01c21727 --- /dev/null +++ b/AndroidAnnotations/androidannotations-api/src/main/java/org/androidannotations/annotations/FocusChange.java @@ -0,0 +1,18 @@ +package org.androidannotations.annotations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * + * @author Rostislav Chekan + */ +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.METHOD) +public @interface FocusChange { + int[] value() default ResId.DEFAULT_VALUE; + + String[] resName() default ""; +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java index ee2e3eee84..ebe5cbb3ff 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java @@ -50,6 +50,7 @@ import org.androidannotations.annotations.EView; import org.androidannotations.annotations.EViewGroup; import org.androidannotations.annotations.Extra; +import org.androidannotations.annotations.FocusChange; import org.androidannotations.annotations.FragmentArg; import org.androidannotations.annotations.FragmentById; import org.androidannotations.annotations.FragmentByTag; @@ -135,6 +136,7 @@ import org.androidannotations.processing.EViewGroupProcessor; import org.androidannotations.processing.EViewProcessor; import org.androidannotations.processing.ExtraProcessor; +import org.androidannotations.processing.FocusChangeProcessor; import org.androidannotations.processing.FragmentArgProcessor; import org.androidannotations.processing.FragmentByIdProcessor; import org.androidannotations.processing.FragmentByTagProcessor; @@ -199,6 +201,7 @@ import org.androidannotations.validation.EViewGroupValidator; import org.androidannotations.validation.EViewValidator; import org.androidannotations.validation.ExtraValidator; +import org.androidannotations.validation.FocusChangeValidator; import org.androidannotations.validation.FragmentArgValidator; import org.androidannotations.validation.FragmentByIdValidator; import org.androidannotations.validation.FragmentByTagValidator; @@ -254,6 +257,7 @@ ItemClick.class, // ItemLongClick.class, // Touch.class, // + FocusChange.class, // ItemSelect.class, // UiThread.class, // Transactional.class, // @@ -449,6 +453,7 @@ private ModelValidator buildModelValidator(IRClass rClass, AndroidSystemServices modelValidator.register(new ClickValidator(processingEnv, rClass)); modelValidator.register(new LongClickValidator(processingEnv, rClass)); modelValidator.register(new TouchValidator(processingEnv, rClass)); + modelValidator.register(new FocusChangeValidator(processingEnv, rClass)); modelValidator.register(new ItemClickValidator(processingEnv, rClass)); modelValidator.register(new ItemSelectedValidator(processingEnv, rClass)); modelValidator.register(new ItemLongClickValidator(processingEnv, rClass)); @@ -539,6 +544,7 @@ private ModelProcessor buildModelProcessor(IRClass rClass, AndroidSystemServices modelProcessor.register(new ClickProcessor(processingEnv, rClass)); modelProcessor.register(new LongClickProcessor(processingEnv, rClass)); modelProcessor.register(new TouchProcessor(processingEnv, rClass)); + modelProcessor.register(new FocusChangeProcessor(processingEnv, rClass)); modelProcessor.register(new ItemClickProcessor(processingEnv, rClass)); modelProcessor.register(new ItemSelectedProcessor(processingEnv, rClass)); modelProcessor.register(new ItemLongClickProcessor(processingEnv, rClass)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FocusChangeProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FocusChangeProcessor.java new file mode 100644 index 0000000000..71dec37ed5 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FocusChangeProcessor.java @@ -0,0 +1,64 @@ +package org.androidannotations.processing; + +import java.lang.annotation.Annotation; +import java.util.List; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.TypeMirror; + +import org.androidannotations.annotations.FocusChange; +import org.androidannotations.rclass.IRClass; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JDefinedClass; +import com.sun.codemodel.JInvocation; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JMod; +import com.sun.codemodel.JVar; + +public class FocusChangeProcessor extends AbstractListenerProcessor { + + public FocusChangeProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { + super(processingEnv, rClass); + } + + @Override + public Class getTarget() { + return FocusChange.class; + } + + @Override + protected void makeCall(JBlock listenerMethodBody, JInvocation call, TypeMirror returnType) { + listenerMethodBody.add(call); + } + + @Override + protected void processParameters(JMethod listenerMethod, JInvocation call, List parameters) { + JVar viewParam = listenerMethod.param(classes.VIEW, "view"); + JVar hasFocusParam = listenerMethod.param(codeModel.BOOLEAN, "hasFocus"); + boolean hasFocusParamExists = parameters.size() == 2; + + call.arg(viewParam); + if (hasFocusParamExists) { + call.arg(hasFocusParam); + } + } + + @Override + protected JMethod createListenerMethod(JDefinedClass listenerAnonymousClass) { + return listenerAnonymousClass.method(JMod.PUBLIC, codeModel.VOID, "onFocusChange"); + } + + @Override + protected String getSetterName() { + return "setOnFocusChangeListener"; + } + + @Override + protected JClass getListenerClass() { + return classes.VIEW_ON_FOCUS_CHANGE_LISTENER; + } + +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FocusChangeValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FocusChangeValidator.java new file mode 100644 index 0000000000..7bb20bfd10 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FocusChangeValidator.java @@ -0,0 +1,70 @@ +/** + * Copyright (C) 2010-2012 eBusiness Information, Excilys Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed To in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package org.androidannotations.validation; + +import java.lang.annotation.Annotation; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; + +import org.androidannotations.annotations.FocusChange; +import org.androidannotations.helper.IdAnnotationHelper; +import org.androidannotations.helper.IdValidatorHelper; +import org.androidannotations.helper.IdValidatorHelper.FallbackStrategy; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.rclass.IRClass; +import org.androidannotations.rclass.IRClass.Res; + +public class FocusChangeValidator implements ElementValidator { + + private IdValidatorHelper validatorHelper; + + public FocusChangeValidator(ProcessingEnvironment processingEnv, IRClass rClass) { + IdAnnotationHelper annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); + validatorHelper = new IdValidatorHelper(annotationHelper); + } + + @Override + public Class getTarget() { + return FocusChange.class; + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); + + validatorHelper.resIdsExist(element, Res.ID, FallbackStrategy.USE_ELEMENT_NAME, valid); + + validatorHelper.isNotPrivate(element, valid); + + validatorHelper.doesntThrowException(element, valid); + + validatorHelper.uniqueId(element, validatedElements, valid); + + ExecutableElement executableElement = (ExecutableElement) element; + validatorHelper.returnTypeIsVoid(executableElement, valid); + + // validatorHelper.zeroOrOneViewParameters(executableElement, valid); + int i = 0; + + return valid.isValid(); + } + +} From 1196bc212d7b036d9d9d9705917b366a89a4c07d Mon Sep 17 00:00:00 2001 From: naixx Date: Thu, 17 Jan 2013 02:41:45 +0300 Subject: [PATCH 3/5] Move parameter checkers form ValidatorHelper to separate class. Add generation test and propper validation for @FocusChange. --- .../helper/ValidatorHelper.java | 112 +------------ .../helper/ValidatorParameterHelper.java | 158 ++++++++++++++++++ .../androidannotations/model/AndroidRes.java | 3 +- .../processing/FocusChangeProcessor.java | 5 +- .../validation/AfterInjectValidator.java | 2 +- .../validation/AfterViewsValidator.java | 2 +- .../validation/ClickValidator.java | 2 +- .../validation/FocusChangeValidator.java | 3 +- .../validation/ItemClickValidator.java | 2 +- .../validation/ItemLongClickValidator.java | 2 +- .../validation/ItemSelectedValidator.java | 2 +- .../validation/LongClickValidator.java | 2 +- .../validation/OptionsItemValidator.java | 2 +- .../validation/TouchValidator.java | 2 +- .../validation/TransactionalValidator.java | 2 +- .../functional-test-1-5/AndroidManifest.xml | 1 + .../test15/FocusChangeHandledActivity.java | 58 +++++++ 17 files changed, 237 insertions(+), 123 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorParameterHelper.java create mode 100644 AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/FocusChangeHandledActivity.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java index 020e943b93..d9a0994c35 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java @@ -78,7 +78,6 @@ public class ValidatorHelper { - private static final List ANDROID_SHERLOCK_MENU_ITEM_QUALIFIED_NAMES = asList(CanonicalNameConstants.MENU_ITEM, CanonicalNameConstants.SHERLOCK_MENU_ITEM); private static final List ANDROID_FRAGMENT_QUALIFIED_NAMES = asList(CanonicalNameConstants.FRAGMENT, CanonicalNameConstants.SUPPORT_V4_FRAGMENT); private static final String METHOD_NAME_SET_ROOT_URL = "setRootUrl"; @@ -97,8 +96,11 @@ public class ValidatorHelper { protected final TargetAnnotationHelper annotationHelper; + public final ValidatorParameterHelper param; + public ValidatorHelper(TargetAnnotationHelper targetAnnotationHelper) { annotationHelper = targetAnnotationHelper; + param = new ValidatorParameterHelper(annotationHelper); } public void isNotFinal(Element element, IsValid valid) { @@ -465,56 +467,6 @@ public void returnTypeIsVoid(ExecutableElement executableElement, IsValid valid) } } - public void zeroOrOneParameter(ExecutableElement executableElement, IsValid valid) { - List parameters = executableElement.getParameters(); - - if (parameters.size() > 1) { - valid.invalidate(); - annotationHelper.printAnnotationError(executableElement, "%s can only be used on a method with zero or one parameter, instead of " + parameters.size()); - } - } - - public void zeroParameter(ExecutableElement executableElement, IsValid valid) { - List parameters = executableElement.getParameters(); - - if (parameters.size() > 0) { - valid.invalidate(); - annotationHelper.printAnnotationError(executableElement, "%s can only be used on a method with zero parameter, instead of " + parameters.size()); - } - } - - public void zeroOrOneViewParameters(ExecutableElement executableElement, IsValid valid) { - zeroOrOneSpecificParameter(executableElement, CanonicalNameConstants.VIEW, valid); - } - - public void zeroOrOneMenuItemParameters(ExecutableElement executableElement, IsValid valid) { - zeroOrOneSpecificParameter(executableElement, ANDROID_SHERLOCK_MENU_ITEM_QUALIFIED_NAMES, valid); - } - - public void zeroOrOneSpecificParameter(ExecutableElement executableElement, String parameterTypeQualifiedName, IsValid valid) { - zeroOrOneSpecificParameter(executableElement, Arrays.asList(parameterTypeQualifiedName), valid); - } - - public void zeroOrOneSpecificParameter(ExecutableElement executableElement, List parameterTypeQualifiedNames, IsValid valid) { - - zeroOrOneParameter(executableElement, valid); - - List parameters = executableElement.getParameters(); - - if (parameters.size() == 1) { - VariableElement parameter = parameters.get(0); - TypeMirror parameterType = parameter.asType(); - if (!parameterTypeQualifiedNames.contains(parameterType.toString())) { - valid.invalidate(); - annotationHelper.printAnnotationError(executableElement, "%s can only be used on a method with no parameter or a parameter of type " + parameterTypeQualifiedNames + ", not " + parameterType); - } - } - } - - public void zeroOrOneBundleParameter(ExecutableElement executableElement, IsValid valid) { - zeroOrOneSpecificParameter(executableElement, CanonicalNameConstants.BUNDLE, valid); - } - public void extendsActivity(Element element, IsValid valid) { extendsType(element, CanonicalNameConstants.ACTIVITY, valid); } @@ -703,24 +655,6 @@ public void extendsType(Element element, String typeQualifiedName, IsValid valid } } - public void hasOneOrTwoParametersAndFirstIsBoolean(ExecutableElement executableElement, IsValid valid) { - List parameters = executableElement.getParameters(); - - if (parameters.size() < 1 || parameters.size() > 2) { - valid.invalidate(); - annotationHelper.printAnnotationError(executableElement, "%s can only be used on a method with 1 or 2 parameter, instead of " + parameters.size()); - } else { - VariableElement firstParameter = parameters.get(0); - - TypeKind parameterKind = firstParameter.asType().getKind(); - - if (parameterKind != TypeKind.BOOLEAN && !firstParameter.toString().equals("java.lang.Boolean")) { - valid.invalidate(); - annotationHelper.printAnnotationError(executableElement, "the first parameter should be a boolean"); - } - } - } - public void allowedType(Element element, IsValid valid, TypeMirror fieldTypeMirror, List allowedTypes) { String qualifiedName = fieldTypeMirror.toString(); @@ -781,46 +715,6 @@ public void androidService(AndroidSystemServices androidSystemServices, Element } } - public void hasOneMotionEventOrTwoMotionEventViewParameters(ExecutableElement executableElement, IsValid valid) { - List parameters = executableElement.getParameters(); - - if (parameters.size() < 1 || parameters.size() > 2) { - valid.invalidate(); - annotationHelper.printAnnotationError(executableElement, "%s can only be used on a method with 1 (MotionEvent) or 2 (MotionEvent, View) parameters, instead of " + parameters.size()); - } else { - VariableElement firstParameter = parameters.get(0); - String firstParameterType = firstParameter.asType().toString(); - if (!firstParameterType.equals(CanonicalNameConstants.MOTION_EVENT)) { - valid.invalidate(); - annotationHelper.printAnnotationError(executableElement, "the first parameter must be a " + CanonicalNameConstants.MOTION_EVENT + ", not a " + firstParameterType); - } - if (parameters.size() == 2) { - VariableElement secondParameter = parameters.get(1); - String secondParameterType = secondParameter.asType().toString(); - if (!secondParameterType.equals(CanonicalNameConstants.VIEW)) { - valid.invalidate(); - annotationHelper.printAnnotationError(executableElement, "the second parameter must be a " + CanonicalNameConstants.VIEW + ", not a " + secondParameterType); - } - } - } - } - - public void hasOneOrTwoParametersAndFirstIsDb(ExecutableElement executableElement, IsValid valid) { - List parameters = executableElement.getParameters(); - - if (parameters.size() < 1) { - valid.invalidate(); - annotationHelper.printAnnotationError(executableElement, "There should be at least 1 parameter: a " + CanonicalNameConstants.SQLITE_DATABASE); - } else { - VariableElement firstParameter = parameters.get(0); - String firstParameterType = firstParameter.asType().toString(); - if (!firstParameterType.equals(CanonicalNameConstants.SQLITE_DATABASE)) { - valid.invalidate(); - annotationHelper.printAnnotationError(executableElement, "the first parameter must be a " + CanonicalNameConstants.SQLITE_DATABASE + ", not a " + firstParameterType); - } - } - } - public void isDeclaredType(Element element, IsValid valid, TypeMirror uiFieldTypeMirror) { if (!(uiFieldTypeMirror instanceof DeclaredType)) { valid.invalidate(); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorParameterHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorParameterHelper.java new file mode 100644 index 0000000000..be6be11319 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorParameterHelper.java @@ -0,0 +1,158 @@ +package org.androidannotations.helper; + +import static java.util.Arrays.asList; + +import java.util.Arrays; +import java.util.List; + +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.TypeKind; +import javax.lang.model.type.TypeMirror; + +import org.androidannotations.validation.IsValid; + +public class ValidatorParameterHelper { + + private static final List ANDROID_SHERLOCK_MENU_ITEM_QUALIFIED_NAMES = asList(CanonicalNameConstants.MENU_ITEM, CanonicalNameConstants.SHERLOCK_MENU_ITEM); + + protected final TargetAnnotationHelper annotationHelper; + + public ValidatorParameterHelper(TargetAnnotationHelper targetAnnotationHelper) { + annotationHelper = targetAnnotationHelper; + } + + public void zeroOrOneParameter(ExecutableElement executableElement, IsValid valid) { + List parameters = executableElement.getParameters(); + + if (parameters.size() > 1) { + valid.invalidate(); + annotationHelper.printAnnotationError(executableElement, "%s can only be used on a method with zero or one parameter, instead of " + parameters.size()); + } + } + + public void zeroParameter(ExecutableElement executableElement, IsValid valid) { + List parameters = executableElement.getParameters(); + + if (parameters.size() > 0) { + valid.invalidate(); + annotationHelper.printAnnotationError(executableElement, "%s can only be used on a method with zero parameter, instead of " + parameters.size()); + } + } + + public void zeroOrOneViewParameters(ExecutableElement executableElement, IsValid valid) { + zeroOrOneSpecificParameter(executableElement, CanonicalNameConstants.VIEW, valid); + } + + public void zeroOrOneMenuItemParameters(ExecutableElement executableElement, IsValid valid) { + zeroOrOneSpecificParameter(executableElement, ANDROID_SHERLOCK_MENU_ITEM_QUALIFIED_NAMES, valid); + } + + public void zeroOrOneSpecificParameter(ExecutableElement executableElement, String parameterTypeQualifiedName, IsValid valid) { + zeroOrOneSpecificParameter(executableElement, Arrays.asList(parameterTypeQualifiedName), valid); + } + + public void zeroOrOneSpecificParameter(ExecutableElement executableElement, List parameterTypeQualifiedNames, IsValid valid) { + + zeroOrOneParameter(executableElement, valid); + + List parameters = executableElement.getParameters(); + + if (parameters.size() == 1) { + VariableElement parameter = parameters.get(0); + TypeMirror parameterType = parameter.asType(); + if (!parameterTypeQualifiedNames.contains(parameterType.toString())) { + valid.invalidate(); + annotationHelper.printAnnotationError(executableElement, "%s can only be used on a method with no parameter or a parameter of type " + parameterTypeQualifiedNames + ", not " + parameterType); + } + } + } + + public void zeroOrOneBundleParameter(ExecutableElement executableElement, IsValid valid) { + zeroOrOneSpecificParameter(executableElement, CanonicalNameConstants.BUNDLE, valid); + } + + public void hasOneOrTwoParametersAndFirstIsBoolean(ExecutableElement executableElement, IsValid valid) { + List parameters = executableElement.getParameters(); + + if (parameters.size() < 1 || parameters.size() > 2) { + valid.invalidate(); + annotationHelper.printAnnotationError(executableElement, "%s can only be used on a method with 1 or 2 parameter, instead of " + parameters.size()); + } else { + VariableElement firstParameter = parameters.get(0); + + TypeKind parameterKind = firstParameter.asType().getKind(); + + if (parameterKind != TypeKind.BOOLEAN && !firstParameter.toString().equals(CanonicalNameConstants.BOOLEAN)) { + valid.invalidate(); + annotationHelper.printAnnotationError(executableElement, "the first parameter should be a boolean"); + } + } + } + + public void hasZeroOrOneViewOrTwoViewBooleanParameters(ExecutableElement executableElement, IsValid valid) { + List parameters = executableElement.getParameters(); + + if (parameters.size() == 0) { + return; + } else if (parameters.size() > 2) { + valid.invalidate(); + annotationHelper.printAnnotationError(executableElement, "%s can only be used on a method with 0 or 1(View) or 2(View, boolean) parameter, instead of " + parameters.size()); + } else { + VariableElement firstParameter = parameters.get(0); + String firstParameterType = firstParameter.asType().toString(); + if (!firstParameterType.equals(CanonicalNameConstants.VIEW)) { + valid.invalidate(); + annotationHelper.printAnnotationError(executableElement, "the first parameter must be a " + CanonicalNameConstants.VIEW + ", not a " + firstParameterType); + } + if (parameters.size() == 2) { + VariableElement secondParameter = parameters.get(1); + String secondParameterType = secondParameter.asType().toString(); + if (!secondParameterType.equals(CanonicalNameConstants.BOOLEAN) && !secondParameterType.equals("boolean")) { + valid.invalidate(); + annotationHelper.printAnnotationError(executableElement, "the second parameter must be a " + CanonicalNameConstants.BOOLEAN + " or boolean, not a " + secondParameterType); + } + } + } + } + + public void hasOneMotionEventOrTwoMotionEventViewParameters(ExecutableElement executableElement, IsValid valid) { + List parameters = executableElement.getParameters(); + + if (parameters.size() < 1 || parameters.size() > 2) { + valid.invalidate(); + annotationHelper.printAnnotationError(executableElement, "%s can only be used on a method with 1 (MotionEvent) or 2 (MotionEvent, View) parameters, instead of " + parameters.size()); + } else { + VariableElement firstParameter = parameters.get(0); + String firstParameterType = firstParameter.asType().toString(); + if (!firstParameterType.equals(CanonicalNameConstants.MOTION_EVENT)) { + valid.invalidate(); + annotationHelper.printAnnotationError(executableElement, "the first parameter must be a " + CanonicalNameConstants.MOTION_EVENT + ", not a " + firstParameterType); + } + if (parameters.size() == 2) { + VariableElement secondParameter = parameters.get(1); + String secondParameterType = secondParameter.asType().toString(); + if (!secondParameterType.equals(CanonicalNameConstants.VIEW)) { + valid.invalidate(); + annotationHelper.printAnnotationError(executableElement, "the second parameter must be a " + CanonicalNameConstants.VIEW + ", not a " + secondParameterType); + } + } + } + } + + public void hasOneOrTwoParametersAndFirstIsDb(ExecutableElement executableElement, IsValid valid) { + List parameters = executableElement.getParameters(); + + if (parameters.size() < 1) { + valid.invalidate(); + annotationHelper.printAnnotationError(executableElement, "There should be at least 1 parameter: a " + CanonicalNameConstants.SQLITE_DATABASE); + } else { + VariableElement firstParameter = parameters.get(0); + String firstParameterType = firstParameter.asType().toString(); + if (!firstParameterType.equals(CanonicalNameConstants.SQLITE_DATABASE)) { + valid.invalidate(); + annotationHelper.printAnnotationError(executableElement, "the first parameter must be a " + CanonicalNameConstants.SQLITE_DATABASE + ", not a " + firstParameterType); + } + } + } +} \ No newline at end of file diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/AndroidRes.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/AndroidRes.java index 77df877b3a..8f3cd44f7c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/AndroidRes.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/AndroidRes.java @@ -46,7 +46,8 @@ public enum AndroidRes { STRING(Res.STRING, StringRes.class, "getString", "java.lang.String"), // STRING_ARRAY(Res.ARRAY, StringArrayRes.class, "getStringArray", "java.lang.String[]"), // ANIMATION(Res.ANIM, AnimationRes.class, "getAnimation", "android.content.res.XmlResourceParser", "android.view.animation.Animation"), // - HTML(Res.STRING, HtmlRes.class, "getString", "java.lang.CharSequence", "android.text.Spanned"), BOOLEAN(Res.BOOL, BooleanRes.class, "getBoolean", "java.lang.Boolean", "boolean"), // + HTML(Res.STRING, HtmlRes.class, "getString", "java.lang.CharSequence", "android.text.Spanned"), // + BOOLEAN(Res.BOOL, BooleanRes.class, "getBoolean", "java.lang.Boolean", "boolean"), // COLOR_STATE_LIST(Res.COLOR, ColorStateListRes.class, "getColorStateList", "android.content.res.ColorStateList"), // DIMENSION(Res.DIMEN, DimensionRes.class, "getDimension", "java.lang.Float", "float"), // DIMENSION_PIXEL_OFFSET(Res.DIMEN, DimensionPixelOffsetRes.class, "getDimensionPixelOffset", "java.lang.Integer", "int"), // diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FocusChangeProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FocusChangeProcessor.java index 71dec37ed5..93586f7f94 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FocusChangeProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FocusChangeProcessor.java @@ -39,8 +39,11 @@ protected void processParameters(JMethod listenerMethod, JInvocation call, List< JVar viewParam = listenerMethod.param(classes.VIEW, "view"); JVar hasFocusParam = listenerMethod.param(codeModel.BOOLEAN, "hasFocus"); boolean hasFocusParamExists = parameters.size() == 2; + boolean viewParamExists = parameters.size() >= 1; - call.arg(viewParam); + if (viewParamExists) { + call.arg(viewParam); + } if (hasFocusParamExists) { call.arg(hasFocusParam); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AfterInjectValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AfterInjectValidator.java index e0e14083b2..81e22aae2d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AfterInjectValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AfterInjectValidator.java @@ -55,7 +55,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.doesntThrowException(executableElement, valid); - validatorHelper.zeroParameter(executableElement, valid); + validatorHelper.param.zeroParameter(executableElement, valid); return valid.isValid(); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AfterViewsValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AfterViewsValidator.java index 3599f09c96..8bca964381 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AfterViewsValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AfterViewsValidator.java @@ -55,7 +55,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.doesntThrowException(executableElement, valid); - validatorHelper.zeroParameter(executableElement, valid); + validatorHelper.param.zeroParameter(executableElement, valid); return valid.isValid(); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ClickValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ClickValidator.java index c46be4031e..ec49ec4525 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ClickValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ClickValidator.java @@ -61,7 +61,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { ExecutableElement executableElement = (ExecutableElement) element; validatorHelper.returnTypeIsVoid(executableElement, valid); - validatorHelper.zeroOrOneViewParameters(executableElement, valid); + validatorHelper.param.zeroOrOneViewParameters(executableElement, valid); return valid.isValid(); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FocusChangeValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FocusChangeValidator.java index 7bb20bfd10..c8a379c82e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FocusChangeValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FocusChangeValidator.java @@ -61,8 +61,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { ExecutableElement executableElement = (ExecutableElement) element; validatorHelper.returnTypeIsVoid(executableElement, valid); - // validatorHelper.zeroOrOneViewParameters(executableElement, valid); - int i = 0; + validatorHelper.param.hasZeroOrOneViewOrTwoViewBooleanParameters(executableElement, valid); return valid.isValid(); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ItemClickValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ItemClickValidator.java index 20225dff2f..95c6951aba 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ItemClickValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ItemClickValidator.java @@ -65,7 +65,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { ExecutableElement executableElement = (ExecutableElement) element; validatorHelper.returnTypeIsVoid(executableElement, valid); - validatorHelper.zeroOrOneParameter(executableElement, valid); + validatorHelper.param.zeroOrOneParameter(executableElement, valid); return valid.isValid(); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ItemLongClickValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ItemLongClickValidator.java index 238f8e8852..3288b5fdcb 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ItemLongClickValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ItemLongClickValidator.java @@ -66,7 +66,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.returnTypeIsVoidOrBoolean(executableElement, valid); - validatorHelper.zeroOrOneParameter(executableElement, valid); + validatorHelper.param.zeroOrOneParameter(executableElement, valid); return valid.isValid(); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ItemSelectedValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ItemSelectedValidator.java index 9bf073bcf3..c2281e0c4d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ItemSelectedValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ItemSelectedValidator.java @@ -65,7 +65,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.returnTypeIsVoid(executableElement, valid); - validatorHelper.hasOneOrTwoParametersAndFirstIsBoolean(executableElement, valid); + validatorHelper.param.hasOneOrTwoParametersAndFirstIsBoolean(executableElement, valid); return valid.isValid(); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/LongClickValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/LongClickValidator.java index 94db9cd681..d433191f87 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/LongClickValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/LongClickValidator.java @@ -66,7 +66,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.returnTypeIsVoidOrBoolean(executableElement, valid); - validatorHelper.zeroOrOneViewParameters(executableElement, valid); + validatorHelper.param.zeroOrOneViewParameters(executableElement, valid); return valid.isValid(); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OptionsItemValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OptionsItemValidator.java index e391cd632b..330a50b531 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OptionsItemValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OptionsItemValidator.java @@ -70,7 +70,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.returnTypeIsVoidOrBoolean(executableElement, valid); - validatorHelper.zeroOrOneMenuItemParameters(executableElement, valid); + validatorHelper.param.zeroOrOneMenuItemParameters(executableElement, valid); return valid.isValid(); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TouchValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TouchValidator.java index 3f1c4dc460..e0f58cb113 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TouchValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TouchValidator.java @@ -62,7 +62,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.returnTypeIsVoidOrBoolean(executableElement, valid); - validatorHelper.hasOneMotionEventOrTwoMotionEventViewParameters(executableElement, valid); + validatorHelper.param.hasOneMotionEventOrTwoMotionEventViewParameters(executableElement, valid); return valid.isValid(); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TransactionalValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TransactionalValidator.java index e83bbd159b..20929cf264 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TransactionalValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TransactionalValidator.java @@ -55,7 +55,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.isNotFinal(element, valid); - validatorHelper.hasOneOrTwoParametersAndFirstIsDb(executableElement, valid); + validatorHelper.param.hasOneOrTwoParametersAndFirstIsDb(executableElement, valid); return valid.isValid(); } diff --git a/AndroidAnnotations/functional-test-1-5/AndroidManifest.xml b/AndroidAnnotations/functional-test-1-5/AndroidManifest.xml index c1f95e9191..f5030f618b 100644 --- a/AndroidAnnotations/functional-test-1-5/AndroidManifest.xml +++ b/AndroidAnnotations/functional-test-1-5/AndroidManifest.xml @@ -40,6 +40,7 @@ + diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/FocusChangeHandledActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/FocusChangeHandledActivity.java new file mode 100644 index 0000000000..1b02ae250a --- /dev/null +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/FocusChangeHandledActivity.java @@ -0,0 +1,58 @@ +/** + * Copyright (C) 2010-2012 eBusiness Information, Excilys Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed To in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package org.androidannotations.test15; + +import android.view.MotionEvent; +import android.view.View; + +import org.androidannotations.annotations.EActivity; +import org.androidannotations.annotations.FocusChange; +import org.androidannotations.annotations.Touch; + +@EActivity(R.layout.clickable_widgets) +public class FocusChangeHandledActivity extends EventsHandledAbstractActivity { + + @FocusChange + public void conventionButton(View evt, boolean hasFocus) { + + } + + @FocusChange + public void snakeCaseButton() { + + } + + @FocusChange + public void extendedConventionButton(View evt) { + + } + + @FocusChange(R.id.configurationOverConventionButton) + public void overridenConventionButton() { + + } + + @FocusChange + public void buttonWithViewArgument() { + + } + + @FocusChange({ R.id.button1, R.id.button2 }) + public void multipleButtonWithViewArgument(View v, boolean hasFocus) { + + } + +} From 85a5434017ceba7ddac52b2772a3892fcafacf58 Mon Sep 17 00:00:00 2001 From: naixx Date: Fri, 18 Jan 2013 04:03:56 +0300 Subject: [PATCH 4/5] Add @CheckedChange #389 --- .../annotations/CheckedChange.java | 19 +++++ .../AndroidAnnotationProcessor.java | 6 ++ .../helper/CanonicalNameConstants.java | 1 + .../helper/ValidatorParameterHelper.java | 26 +++++++ .../processing/AbstractListenerProcessor.java | 12 ++- .../processing/CheckedChangeProcessor.java | 78 +++++++++++++++++++ .../processing/EBeansHolder.java | 1 + .../processing/FocusChangeProcessor.java | 6 +- .../validation/CheckedChangeValidator.java | 69 ++++++++++++++++ .../functional-test-1-5/AndroidManifest.xml | 1 + .../test15/CheckedChangeHandledActivity.java | 58 ++++++++++++++ .../test15/FocusChangeHandledActivity.java | 6 +- 12 files changed, 275 insertions(+), 8 deletions(-) create mode 100644 AndroidAnnotations/androidannotations-api/src/main/java/org/androidannotations/annotations/CheckedChange.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/CheckedChangeProcessor.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/CheckedChangeValidator.java create mode 100644 AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/CheckedChangeHandledActivity.java diff --git a/AndroidAnnotations/androidannotations-api/src/main/java/org/androidannotations/annotations/CheckedChange.java b/AndroidAnnotations/androidannotations-api/src/main/java/org/androidannotations/annotations/CheckedChange.java new file mode 100644 index 0000000000..ea2c1be8b8 --- /dev/null +++ b/AndroidAnnotations/androidannotations-api/src/main/java/org/androidannotations/annotations/CheckedChange.java @@ -0,0 +1,19 @@ +package org.androidannotations.annotations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + + +/** + * + * @author Rostislav Chekan + */ +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.METHOD) +public @interface CheckedChange { + int[] value() default ResId.DEFAULT_VALUE; + + String[] resName() default ""; +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java index ebe5cbb3ff..d067603a11 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java @@ -39,6 +39,7 @@ import org.androidannotations.annotations.Background; import org.androidannotations.annotations.Bean; import org.androidannotations.annotations.BeforeTextChange; +import org.androidannotations.annotations.CheckedChange; import org.androidannotations.annotations.Click; import org.androidannotations.annotations.EActivity; import org.androidannotations.annotations.EApplication; @@ -125,6 +126,7 @@ import org.androidannotations.processing.BackgroundProcessor; import org.androidannotations.processing.BeanProcessor; import org.androidannotations.processing.BeforeTextChangeProcessor; +import org.androidannotations.processing.CheckedChangeProcessor; import org.androidannotations.processing.ClickProcessor; import org.androidannotations.processing.EActivityProcessor; import org.androidannotations.processing.EApplicationProcessor; @@ -190,6 +192,7 @@ import org.androidannotations.validation.AppValidator; import org.androidannotations.validation.BeanValidator; import org.androidannotations.validation.BeforeTextChangeValidator; +import org.androidannotations.validation.CheckedChangeValidator; import org.androidannotations.validation.ClickValidator; import org.androidannotations.validation.EActivityValidator; import org.androidannotations.validation.EApplicationValidator; @@ -258,6 +261,7 @@ ItemLongClick.class, // Touch.class, // FocusChange.class, // + CheckedChange.class, // ItemSelect.class, // UiThread.class, // Transactional.class, // @@ -454,6 +458,7 @@ private ModelValidator buildModelValidator(IRClass rClass, AndroidSystemServices modelValidator.register(new LongClickValidator(processingEnv, rClass)); modelValidator.register(new TouchValidator(processingEnv, rClass)); modelValidator.register(new FocusChangeValidator(processingEnv, rClass)); + modelValidator.register(new CheckedChangeValidator(processingEnv, rClass)); modelValidator.register(new ItemClickValidator(processingEnv, rClass)); modelValidator.register(new ItemSelectedValidator(processingEnv, rClass)); modelValidator.register(new ItemLongClickValidator(processingEnv, rClass)); @@ -545,6 +550,7 @@ private ModelProcessor buildModelProcessor(IRClass rClass, AndroidSystemServices modelProcessor.register(new LongClickProcessor(processingEnv, rClass)); modelProcessor.register(new TouchProcessor(processingEnv, rClass)); modelProcessor.register(new FocusChangeProcessor(processingEnv, rClass)); + modelProcessor.register(new CheckedChangeProcessor(processingEnv, rClass)); modelProcessor.register(new ItemClickProcessor(processingEnv, rClass)); modelProcessor.register(new ItemSelectedProcessor(processingEnv, rClass)); modelProcessor.register(new ItemLongClickProcessor(processingEnv, rClass)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/CanonicalNameConstants.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/CanonicalNameConstants.java index 93c00df8d6..b70b9fadf6 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/CanonicalNameConstants.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/CanonicalNameConstants.java @@ -48,6 +48,7 @@ public final class CanonicalNameConstants { public static final String SEEKBAR = "android.widget.SeekBar"; public static final String ON_SEEKBAR_CHANGE_LISTENER = "android.widget.SeekBar.OnSeekBarChangeListener"; public static final String TEXT_VIEW = "android.widget.TextView"; + public static final String COMPOUND_BUTTON = "android.widget.CompoundButton"; public static final String VIEW = "android.view.View"; public static final String VIEW_ON_CLICK_LISTENER = "android.view.View.OnClickListener"; public static final String VIEW_ON_TOUCH_LISTENER = "android.view.View.OnTouchListener"; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorParameterHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorParameterHelper.java index be6be11319..c8994b1750 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorParameterHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorParameterHelper.java @@ -116,6 +116,32 @@ public void hasZeroOrOneViewOrTwoViewBooleanParameters(ExecutableElement executa } } + public void hasZeroOrOneCompoundButtonOrTwoCompoundButtonBooleanParameters(ExecutableElement executableElement, IsValid valid) { + List parameters = executableElement.getParameters(); + + if (parameters.size() == 0) { + return; + } else if (parameters.size() > 2) { + valid.invalidate(); + annotationHelper.printAnnotationError(executableElement, "%s can only be used on a method with 0 or 1(CompoundButton) or 2(CompoundButton, boolean) parameter, instead of " + parameters.size()); + } else { + VariableElement firstParameter = parameters.get(0); + String firstParameterType = firstParameter.asType().toString(); + if (!firstParameterType.equals(CanonicalNameConstants.COMPOUND_BUTTON)) { + valid.invalidate(); + annotationHelper.printAnnotationError(executableElement, "the first parameter must be a " + CanonicalNameConstants.COMPOUND_BUTTON + ", not a " + firstParameterType); + } + if (parameters.size() == 2) { + VariableElement secondParameter = parameters.get(1); + String secondParameterType = secondParameter.asType().toString(); + if (!secondParameterType.equals(CanonicalNameConstants.BOOLEAN) && !secondParameterType.equals("boolean")) { + valid.invalidate(); + annotationHelper.printAnnotationError(executableElement, "the second parameter must be a " + CanonicalNameConstants.BOOLEAN + " or boolean, not a " + secondParameterType); + } + } + } + } + public void hasOneMotionEventOrTwoMotionEventViewParameters(ExecutableElement executableElement, IsValid valid) { List parameters = executableElement.getParameters(); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AbstractListenerProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AbstractListenerProcessor.java index 1b7f731353..d94b129d7d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AbstractListenerProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AbstractListenerProcessor.java @@ -52,15 +52,17 @@ public abstract class AbstractListenerProcessor implements DecoratingElementProc private IdAnnotationHelper helper; protected Classes classes; protected JCodeModel codeModel; + protected EBeanHolder holder; public AbstractListenerProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { helper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); } @Override - public void process(Element element, JCodeModel jcodeModel, EBeanHolder holder) { + public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { classes = holder.classes(); - codeModel = jcodeModel; + this.codeModel = codeModel; + this.holder = holder; String methodName = element.getSimpleName().toString(); @@ -88,7 +90,7 @@ public void process(Element element, JCodeModel jcodeModel, EBeanHolder holder) JInvocation findViewById = invoke("findViewById"); JVar view = block.decl(classes.VIEW, "view", findViewById.arg(idRef)); - block._if(view.ne(_null()))._then().invoke(view, getSetterName()).arg(_new(listenerAnonymousClass)); + block._if(view.ne(_null()))._then().invoke(castWidget(view), getSetterName()).arg(_new(listenerAnonymousClass)); } } @@ -102,4 +104,8 @@ public void process(Element element, JCodeModel jcodeModel, EBeanHolder holder) protected abstract JClass getListenerClass(); + protected JExpression castWidget(JVar view) { + return view; + } + } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/CheckedChangeProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/CheckedChangeProcessor.java new file mode 100644 index 0000000000..198cd2e125 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/CheckedChangeProcessor.java @@ -0,0 +1,78 @@ +package org.androidannotations.processing; + +import java.lang.annotation.Annotation; +import java.util.List; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.TypeMirror; + +import org.androidannotations.annotations.CheckedChange; +import org.androidannotations.rclass.IRClass; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JDefinedClass; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JInvocation; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JMod; +import com.sun.codemodel.JVar; + +/** + * + * @author Rostislav Chekan + * + */ +public class CheckedChangeProcessor extends AbstractListenerProcessor { + + public CheckedChangeProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { + super(processingEnv, rClass); + } + + @Override + public Class getTarget() { + return CheckedChange.class; + } + + @Override + protected void makeCall(JBlock listenerMethodBody, JInvocation call, TypeMirror returnType) { + listenerMethodBody.add(call); + } + + @Override + protected void processParameters(JMethod listenerMethod, JInvocation call, List parameters) { + JVar btnParam = listenerMethod.param(classes.COMPOUND_BUTTON, "buttonView"); + JVar isCheckedParam = listenerMethod.param(codeModel.BOOLEAN, "isChecked"); + boolean isCheckedParamExists = parameters.size() == 2; + boolean btnParamExists = parameters.size() >= 1; + + if (btnParamExists) { + call.arg(btnParam); + } + if (isCheckedParamExists) { + call.arg(isCheckedParam); + } + } + + @Override + protected JMethod createListenerMethod(JDefinedClass listenerAnonymousClass) { + return listenerAnonymousClass.method(JMod.PUBLIC, codeModel.VOID, "onCheckedChanged"); + } + + @Override + protected String getSetterName() { + return "setOnCheckedChangeListener"; + } + + @Override + protected JClass getListenerClass() { + return holder.refClass("android.widget.CompoundButton.OnCheckedChangeListener"); + } + + @Override + protected JExpression castWidget(JVar view) { + return JExpr.cast(classes.COMPOUND_BUTTON, view); + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EBeansHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EBeansHolder.java index 6bae8411f5..4616a59898 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EBeansHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EBeansHolder.java @@ -62,6 +62,7 @@ public class Classes { public final JClass SEEKBAR = refClass(CanonicalNameConstants.SEEKBAR); public final JClass ON_SEEKBAR_CHANGE_LISTENER = refClass(CanonicalNameConstants.ON_SEEKBAR_CHANGE_LISTENER); public final JClass TEXT_VIEW = refClass(CanonicalNameConstants.TEXT_VIEW); + public final JClass COMPOUND_BUTTON = refClass(CanonicalNameConstants.COMPOUND_BUTTON); public final JClass VIEW = refClass(CanonicalNameConstants.VIEW); public final JClass VIEW_ON_CLICK_LISTENER = refClass(CanonicalNameConstants.VIEW_ON_CLICK_LISTENER); public final JClass VIEW_ON_TOUCH_LISTENER = refClass(CanonicalNameConstants.VIEW_ON_TOUCH_LISTENER); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FocusChangeProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FocusChangeProcessor.java index 93586f7f94..004288a8a6 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FocusChangeProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FocusChangeProcessor.java @@ -18,6 +18,11 @@ import com.sun.codemodel.JMod; import com.sun.codemodel.JVar; +/** + * + * @author Rostislav Chekan + * + */ public class FocusChangeProcessor extends AbstractListenerProcessor { public FocusChangeProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { @@ -63,5 +68,4 @@ protected String getSetterName() { protected JClass getListenerClass() { return classes.VIEW_ON_FOCUS_CHANGE_LISTENER; } - } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/CheckedChangeValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/CheckedChangeValidator.java new file mode 100644 index 0000000000..b99eb373ec --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/CheckedChangeValidator.java @@ -0,0 +1,69 @@ +/** + * Copyright (C) 2010-2012 eBusiness Information, Excilys Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed To in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package org.androidannotations.validation; + +import java.lang.annotation.Annotation; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; + +import org.androidannotations.annotations.CheckedChange; +import org.androidannotations.helper.IdAnnotationHelper; +import org.androidannotations.helper.IdValidatorHelper; +import org.androidannotations.helper.IdValidatorHelper.FallbackStrategy; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.rclass.IRClass; +import org.androidannotations.rclass.IRClass.Res; + +public class CheckedChangeValidator implements ElementValidator { + + private IdValidatorHelper validatorHelper; + + public CheckedChangeValidator(ProcessingEnvironment processingEnv, IRClass rClass) { + IdAnnotationHelper annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); + validatorHelper = new IdValidatorHelper(annotationHelper); + } + + @Override + public Class getTarget() { + return CheckedChange.class; + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); + + validatorHelper.resIdsExist(element, Res.ID, FallbackStrategy.USE_ELEMENT_NAME, valid); + + validatorHelper.isNotPrivate(element, valid); + + validatorHelper.doesntThrowException(element, valid); + + validatorHelper.uniqueId(element, validatedElements, valid); + + ExecutableElement executableElement = (ExecutableElement) element; + validatorHelper.returnTypeIsVoid(executableElement, valid); + + validatorHelper.param.hasZeroOrOneCompoundButtonOrTwoCompoundButtonBooleanParameters(executableElement, valid); + + return valid.isValid(); + } + +} diff --git a/AndroidAnnotations/functional-test-1-5/AndroidManifest.xml b/AndroidAnnotations/functional-test-1-5/AndroidManifest.xml index f5030f618b..9d01926d74 100644 --- a/AndroidAnnotations/functional-test-1-5/AndroidManifest.xml +++ b/AndroidAnnotations/functional-test-1-5/AndroidManifest.xml @@ -41,6 +41,7 @@ + diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/CheckedChangeHandledActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/CheckedChangeHandledActivity.java new file mode 100644 index 0000000000..cbf97ae8c2 --- /dev/null +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/CheckedChangeHandledActivity.java @@ -0,0 +1,58 @@ +/** + * Copyright (C) 2010-2012 eBusiness Information, Excilys Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed To in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package org.androidannotations.test15; + +import org.androidannotations.annotations.CheckedChange; +import org.androidannotations.annotations.EActivity; +import org.androidannotations.annotations.FocusChange; + +import android.view.View; +import android.widget.CompoundButton; + +@EActivity(R.layout.clickable_widgets) +public class CheckedChangeHandledActivity extends EventsHandledAbstractActivity { + + @CheckedChange + public void conventionButton(CompoundButton evt, boolean hasFocus) { + + } + + @CheckedChange + public void snakeCaseButton() { + + } + + @CheckedChange + public void extendedConventionButton(CompoundButton evt) { + + } + + @CheckedChange(R.id.configurationOverConventionButton) + public void overridenConventionButton() { + + } + + @CheckedChange + public void buttonWithViewArgument() { + + } + + @CheckedChange({ R.id.button1, R.id.button2 }) + public void multipleButtonWithViewArgument(CompoundButton v, boolean hasFocus) { + + } + +} diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/FocusChangeHandledActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/FocusChangeHandledActivity.java index 1b02ae250a..53b9e9df70 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/FocusChangeHandledActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/FocusChangeHandledActivity.java @@ -15,12 +15,10 @@ */ package org.androidannotations.test15; -import android.view.MotionEvent; -import android.view.View; - import org.androidannotations.annotations.EActivity; import org.androidannotations.annotations.FocusChange; -import org.androidannotations.annotations.Touch; + +import android.view.View; @EActivity(R.layout.clickable_widgets) public class FocusChangeHandledActivity extends EventsHandledAbstractActivity { From 07468b234bf0144f895659eedfdb1dea1880f3d3 Mon Sep 17 00:00:00 2001 From: naixx Date: Fri, 18 Jan 2013 23:17:45 +0300 Subject: [PATCH 5/5] Add headers, rename some methods --- .../helper/ValidatorParameterHelper.java | 24 +++++++++++++++++-- .../processing/CheckedChangeProcessor.java | 15 ++++++++++++ .../processing/FocusChangeProcessor.java | 15 ++++++++++++ .../processing/LongClickProcessor.java | 20 ++++++++++++++++ .../processing/TouchProcessor.java | 15 ++++++++++++ .../validation/CheckedChangeValidator.java | 5 ++++ .../validation/ClickValidator.java | 2 +- .../validation/FocusChangeValidator.java | 5 ++++ .../validation/LongClickValidator.java | 2 +- .../validation/OptionsItemValidator.java | 2 +- 10 files changed, 100 insertions(+), 5 deletions(-) diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorParameterHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorParameterHelper.java index c8994b1750..beaab54fae 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorParameterHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorParameterHelper.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2012 eBusiness Information, Excilys Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed To in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ package org.androidannotations.helper; import static java.util.Arrays.asList; @@ -12,6 +27,11 @@ import org.androidannotations.validation.IsValid; +/** + * + * @author Rostislav Chekan + * + */ public class ValidatorParameterHelper { private static final List ANDROID_SHERLOCK_MENU_ITEM_QUALIFIED_NAMES = asList(CanonicalNameConstants.MENU_ITEM, CanonicalNameConstants.SHERLOCK_MENU_ITEM); @@ -40,11 +60,11 @@ public void zeroParameter(ExecutableElement executableElement, IsValid valid) { } } - public void zeroOrOneViewParameters(ExecutableElement executableElement, IsValid valid) { + public void zeroOrOneViewParameter(ExecutableElement executableElement, IsValid valid) { zeroOrOneSpecificParameter(executableElement, CanonicalNameConstants.VIEW, valid); } - public void zeroOrOneMenuItemParameters(ExecutableElement executableElement, IsValid valid) { + public void zeroOrOneMenuItemParameter(ExecutableElement executableElement, IsValid valid) { zeroOrOneSpecificParameter(executableElement, ANDROID_SHERLOCK_MENU_ITEM_QUALIFIED_NAMES, valid); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/CheckedChangeProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/CheckedChangeProcessor.java index 198cd2e125..2c3e7eec40 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/CheckedChangeProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/CheckedChangeProcessor.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2012 eBusiness Information, Excilys Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed To in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ package org.androidannotations.processing; import java.lang.annotation.Annotation; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FocusChangeProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FocusChangeProcessor.java index 004288a8a6..32b61baec1 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FocusChangeProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FocusChangeProcessor.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2012 eBusiness Information, Excilys Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed To in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ package org.androidannotations.processing; import java.lang.annotation.Annotation; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/LongClickProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/LongClickProcessor.java index e67b657614..faa9f8517c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/LongClickProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/LongClickProcessor.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2012 eBusiness Information, Excilys Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed To in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ package org.androidannotations.processing; import java.lang.annotation.Annotation; @@ -20,6 +35,11 @@ import com.sun.codemodel.JMod; import com.sun.codemodel.JVar; +/** + * + * @author Rostislav Chekan + * + */ public class LongClickProcessor extends AbstractListenerProcessor { public LongClickProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TouchProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TouchProcessor.java index d9ca2cc9a6..8e335ec76d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TouchProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TouchProcessor.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2012 eBusiness Information, Excilys Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed To in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ package org.androidannotations.processing; import java.lang.annotation.Annotation; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/CheckedChangeValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/CheckedChangeValidator.java index b99eb373ec..64b4fc93e7 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/CheckedChangeValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/CheckedChangeValidator.java @@ -29,6 +29,11 @@ import org.androidannotations.rclass.IRClass; import org.androidannotations.rclass.IRClass.Res; +/** + * + * @author Rostislav Chekan + * + */ public class CheckedChangeValidator implements ElementValidator { private IdValidatorHelper validatorHelper; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ClickValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ClickValidator.java index ec49ec4525..ffbaaa0967 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ClickValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ClickValidator.java @@ -61,7 +61,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { ExecutableElement executableElement = (ExecutableElement) element; validatorHelper.returnTypeIsVoid(executableElement, valid); - validatorHelper.param.zeroOrOneViewParameters(executableElement, valid); + validatorHelper.param.zeroOrOneViewParameter(executableElement, valid); return valid.isValid(); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FocusChangeValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FocusChangeValidator.java index c8a379c82e..18f85159af 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FocusChangeValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FocusChangeValidator.java @@ -29,6 +29,11 @@ import org.androidannotations.rclass.IRClass; import org.androidannotations.rclass.IRClass.Res; +/** + * + * @author Rostislav Chekan + * + */ public class FocusChangeValidator implements ElementValidator { private IdValidatorHelper validatorHelper; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/LongClickValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/LongClickValidator.java index d433191f87..50bbd07d13 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/LongClickValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/LongClickValidator.java @@ -66,7 +66,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.returnTypeIsVoidOrBoolean(executableElement, valid); - validatorHelper.param.zeroOrOneViewParameters(executableElement, valid); + validatorHelper.param.zeroOrOneViewParameter(executableElement, valid); return valid.isValid(); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OptionsItemValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OptionsItemValidator.java index 330a50b531..68278f12a6 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OptionsItemValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OptionsItemValidator.java @@ -70,7 +70,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.returnTypeIsVoidOrBoolean(executableElement, valid); - validatorHelper.param.zeroOrOneMenuItemParameters(executableElement, valid); + validatorHelper.param.zeroOrOneMenuItemParameter(executableElement, valid); return valid.isValid(); }