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-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 a19e8b4553..546d491c52 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java @@ -46,6 +46,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.CustomTitle; import org.androidannotations.annotations.EActivity; @@ -58,6 +59,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; @@ -133,6 +135,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.CustomTitleProcessor; import org.androidannotations.processing.EActivityProcessor; @@ -145,6 +148,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; @@ -201,6 +205,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.CustomTitleValidator; import org.androidannotations.validation.EActivityValidator; @@ -213,6 +218,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; @@ -392,6 +398,8 @@ 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 CheckedChangeValidator(processingEnv, rClass)); modelValidator.register(new ItemClickValidator(processingEnv, rClass)); modelValidator.register(new ItemSelectedValidator(processingEnv, rClass)); modelValidator.register(new ItemLongClickValidator(processingEnv, rClass)); @@ -487,6 +495,8 @@ 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 CheckedChangeProcessor(processingEnv, rClass)); modelProcessor.register(new ItemClickProcessor(processingEnv, rClass)); modelProcessor.register(new ItemSelectedProcessor(processingEnv, rClass)); modelProcessor.register(new ItemLongClickProcessor(processingEnv, rClass)); @@ -589,6 +599,8 @@ public Set getSupportedAnnotationTypes() { Click.class, // LongClick.class, // ItemClick.class, // + FocusChange.class, // + CheckedChange.class, // ItemLongClick.class, // Touch.class, // ItemSelect.class, // 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 d416f40be0..13b3a0ea30 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/CanonicalNameConstants.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/CanonicalNameConstants.java @@ -58,8 +58,12 @@ 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"; + 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"; @@ -74,7 +78,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"; @@ -84,7 +87,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/helper/ValidatorHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java index 63c317b05d..004fd4ca6a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java @@ -76,7 +76,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"; @@ -89,8 +88,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) { @@ -473,56 +475,6 @@ public void returnTypeIsNotVoid(ExecutableElement executableElement, IsValid val } } - 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); } @@ -688,32 +640,6 @@ public void extendsType(Element element, String typeQualifiedName, IsValid valid } } - public void hasExactlyOneParameter(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 exactly one parameter, instead of " + parameters.size()); - } - } - - 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 allowedType(Element element, IsValid valid, TypeMirror fieldTypeMirror, List allowedTypes) { String qualifiedName = fieldTypeMirror.toString(); @@ -774,46 +700,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..94fc1b39c4 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorParameterHelper.java @@ -0,0 +1,212 @@ +/** + * 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; + +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; + +/** + * + * @author Rostislav Chekan + * + */ +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 zeroOrOneViewParameter(ExecutableElement executableElement, IsValid valid) { + zeroOrOneSpecificParameter(executableElement, CanonicalNameConstants.VIEW, valid); + } + + public void zeroOrOneMenuItemParameter(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 hasExactlyOneParameter(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 exactly one parameter, instead of " + parameters.size()); + } + } + + 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 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(); + + 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 819391e2f1..b98f8777b4 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/AbstractListenerProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AbstractListenerProcessor.java new file mode 100644 index 0000000000..0465e057c1 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AbstractListenerProcessor.java @@ -0,0 +1,110 @@ +/** + * 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; + protected EBeanHolder holder; + + public AbstractListenerProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { + helper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); + } + + @Override + public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { + classes = holder.classes(); + this.codeModel = codeModel; + this.holder = holder; + + 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); + + ViewChangedHolder onViewChanged = holder.onViewChanged(); + for (JFieldRef idRef : idsRefs) { + JBlock block = onViewChanged.body().block(); + JVar view = block.decl(classes.VIEW, "view", onViewChanged.findViewById(idRef)); + block._if(view.ne(_null()))._then().invoke(castWidget(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(); + + 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..61e678a464 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/CheckedChangeProcessor.java @@ -0,0 +1,92 @@ +/** + * 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.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 String getTarget() { + return CheckedChange.class.getName(); + } + + @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/ClickProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ClickProcessor.java index ea6ac55830..ccb829cb44 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ClickProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ClickProcessor.java @@ -15,40 +15,27 @@ */ package org.androidannotations.processing; -import static com.sun.codemodel.JExpr._new; -import static com.sun.codemodel.JExpr._null; - 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; -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 @@ -57,37 +44,34 @@ public String 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); } + } - ViewChangedHolder onViewChanged = holder.onViewChanged(); - for (JFieldRef idRef : idsRefs) { - JBlock block = onViewChanged.body().block(); - JVar view = block.decl(classes.VIEW, "view", onViewChanged.findViewById(idRef)); - block._if(view.ne(_null()))._then().invoke(view, "setOnClickListener").arg(_new(onClickListenerClass)); - } + @Override + protected JMethod createListenerMethod(JDefinedClass listenerAnonymousClass) { + return listenerAnonymousClass.method(JMod.PUBLIC, codeModel.VOID, "onClick"); + } + @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 4fed709727..48ccd19bb4 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EBeansHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EBeansHolder.java @@ -63,8 +63,12 @@ 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); + 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); @@ -81,7 +85,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); @@ -90,7 +93,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); public final JClass VIEW_SERVER = refClass(CanonicalNameConstants.VIEW_SERVER); 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..b2d885024c --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FocusChangeProcessor.java @@ -0,0 +1,85 @@ +/** + * 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.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; + +/** + * + * @author Rostislav Chekan + * + */ +public class FocusChangeProcessor extends AbstractListenerProcessor { + + public FocusChangeProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { + super(processingEnv, rClass); + } + + @Override + public String getTarget() { + return FocusChange.class.getName(); + } + + @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; + boolean viewParamExists = parameters.size() >= 1; + + if (viewParamExists) { + 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/processing/LongClickProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/LongClickProcessor.java index add54605d9..66e1a23bbd 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/LongClickProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/LongClickProcessor.java @@ -18,35 +18,26 @@ 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; -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 @@ -55,48 +46,38 @@ public String 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); } + } + + @Override + protected JMethod createListenerMethod(JDefinedClass listenerAnonymousClass) { + return listenerAnonymousClass.method(JMod.PUBLIC, codeModel.BOOLEAN, "onLongClick"); + } - ViewChangedHolder onViewChanged = holder.onViewChanged(); - for (JFieldRef idRef : idsRefs) { - JBlock block = onViewChanged.body().block(); + @Override + protected String getSetterName() { + return "setOnLongClickListener"; + } - JVar view = block.decl(classes.VIEW, "view", onViewChanged.findViewById(idRef)); - block._if(view.ne(JExpr._null()))._then().invoke(view, "setOnLongClickListener").arg(JExpr._new(listenerAnonymousClass)); - } + @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 61d30272a9..338944342d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TouchProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TouchProcessor.java @@ -15,29 +15,20 @@ */ package org.androidannotations.processing; -import static com.sun.codemodel.JExpr._new; -import static com.sun.codemodel.JExpr._null; - 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; @@ -45,12 +36,10 @@ /** */ -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 @@ -59,51 +48,42 @@ public String 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); } + } - ViewChangedHolder onViewChanged = holder.onViewChanged(); - for (JFieldRef idRef : idsRefs) { - JBlock block = onViewChanged.body().block(); + @Override + protected JMethod createListenerMethod(JDefinedClass listenerAnonymousClass) { + return listenerAnonymousClass.method(JMod.PUBLIC, codeModel.BOOLEAN, "onTouch"); + } - JVar view = block.decl(classes.VIEW, "view", onViewChanged.findViewById(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; } } 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 1b99e1ba98..59e863f6c6 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AfterInjectValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AfterInjectValidator.java @@ -53,7 +53,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 46cb890fe0..661b1daaa1 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AfterViewsValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AfterViewsValidator.java @@ -53,7 +53,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/CheckedChangeValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/CheckedChangeValidator.java new file mode 100644 index 0000000000..1720e9778b --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/CheckedChangeValidator.java @@ -0,0 +1,72 @@ +/** + * 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 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; + +/** + * + * @author Rostislav Chekan + * + */ +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 String getTarget() { + return CheckedChange.class.getName(); + } + + @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/androidannotations/src/main/java/org/androidannotations/validation/ClickValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ClickValidator.java index aa8e82fb06..8093cf3d26 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ClickValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ClickValidator.java @@ -59,7 +59,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { ExecutableElement executableElement = (ExecutableElement) element; validatorHelper.returnTypeIsVoid(executableElement, valid); - validatorHelper.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 new file mode 100644 index 0000000000..35dda37685 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FocusChangeValidator.java @@ -0,0 +1,72 @@ +/** + * 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 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; + +/** + * + * @author Rostislav Chekan + * + */ +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 String getTarget() { + return FocusChange.class.getName(); + } + + @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.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 542219bcdf..859d0af894 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ItemClickValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ItemClickValidator.java @@ -59,7 +59,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 137eaba447..08d8af4b4b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ItemLongClickValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ItemLongClickValidator.java @@ -60,7 +60,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 dc62e41136..c0e98089ea 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ItemSelectedValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ItemSelectedValidator.java @@ -62,7 +62,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 ef17493eb5..425fa3c6eb 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/LongClickValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/LongClickValidator.java @@ -60,7 +60,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.returnTypeIsVoidOrBoolean(executableElement, valid); - validatorHelper.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 5c400b4439..1d8eddf1de 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OptionsItemValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OptionsItemValidator.java @@ -67,7 +67,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.returnTypeIsVoidOrBoolean(executableElement, valid); - validatorHelper.zeroOrOneMenuItemParameters(executableElement, valid); + validatorHelper.param.zeroOrOneMenuItemParameter(executableElement, valid); return valid.isValid(); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ProduceValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ProduceValidator.java index cd1b3cf3c0..aefac17fe0 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ProduceValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ProduceValidator.java @@ -64,7 +64,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.isNotFinal(element, valid); - validatorHelper.zeroParameter(executableElement, valid); + validatorHelper.param.zeroParameter(executableElement, valid); return valid.isValid(); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SubscribeValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SubscribeValidator.java index 8cd0db7155..bd51fb91e2 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SubscribeValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SubscribeValidator.java @@ -64,7 +64,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.isNotFinal(element, valid); - validatorHelper.hasExactlyOneParameter(executableElement, valid); + validatorHelper.param.hasExactlyOneParameter(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 fa0e1c197e..15d0ac29de 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TouchValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TouchValidator.java @@ -60,7 +60,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 e54fa514a1..769d7cd1ac 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TransactionalValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TransactionalValidator.java @@ -53,7 +53,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 6a4f648d59..9ac6259141 100644 --- a/AndroidAnnotations/functional-test-1-5/AndroidManifest.xml +++ b/AndroidAnnotations/functional-test-1-5/AndroidManifest.xml @@ -43,6 +43,8 @@ + + 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 new file mode 100644 index 0000000000..53b9e9df70 --- /dev/null +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/FocusChangeHandledActivity.java @@ -0,0 +1,56 @@ +/** + * 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.EActivity; +import org.androidannotations.annotations.FocusChange; + +import android.view.View; + +@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) { + + } + +}