From 3b33792aecd9789bdb22db4718bfa816bd4764ce Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Tue, 4 Jun 2013 22:56:12 +0200 Subject: [PATCH 01/86] Define new architecture --- .../AndroidAnnotationProcessor.java | 295 +++--------------- .../generation/CodeModelGenerator.java | 10 +- .../handler/AnnotationHandler.java | 19 ++ .../handler/AnnotationHandlers.java | 66 ++++ .../handler/BaseAnnotationHandler.java | 54 ++++ .../handler/GeneratingAnnotationHandler.java | 11 + .../holder/BaseGeneratedClassHolder.java | 78 +++++ .../holder/EComponentHolder.java | 37 +++ .../holder/GeneratedClassHolder.java | 23 ++ .../process/ModelProcessor.java | 148 +++++++++ .../process/ModelValidator.java | 62 ++++ .../process/ProcessHolder.java | 258 +++++++++++++++ 12 files changed, 801 insertions(+), 260 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BaseAnnotationHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/GeneratingAnnotationHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/BaseGeneratedClassHolder.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/GeneratedClassHolder.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ModelProcessor.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ModelValidator.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ProcessHolder.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java index 355828169c..b1da3a18dc 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java @@ -15,276 +15,53 @@ */ package org.androidannotations; -import static org.androidannotations.helper.AndroidManifestFinder.ANDROID_MANIFEST_FILE_OPTION; -import static org.androidannotations.helper.CanonicalNameConstants.PRODUCE; -import static org.androidannotations.helper.CanonicalNameConstants.SUBSCRIBE; -import static org.androidannotations.helper.ModelConstants.TRACE_OPTION; - -import java.io.IOException; -import java.io.PrintWriter; -import java.io.StringWriter; -import java.util.Collections; -import java.util.HashSet; -import java.util.Map; -import java.util.Set; - -import javax.annotation.processing.AbstractProcessor; -import javax.annotation.processing.Messager; -import javax.annotation.processing.ProcessingEnvironment; -import javax.annotation.processing.RoundEnvironment; -import javax.annotation.processing.SupportedOptions; -import javax.annotation.processing.SupportedSourceVersion; -import javax.lang.model.SourceVersion; -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; -import javax.tools.Diagnostic; - -import org.androidannotations.annotations.AfterInject; -import org.androidannotations.annotations.AfterTextChange; -import org.androidannotations.annotations.AfterViews; -import org.androidannotations.annotations.App; -import org.androidannotations.annotations.Background; -import org.androidannotations.annotations.Bean; -import org.androidannotations.annotations.BeforeTextChange; -import org.androidannotations.annotations.Click; -import org.androidannotations.annotations.CustomTitle; -import org.androidannotations.annotations.EActivity; -import org.androidannotations.annotations.EApplication; -import org.androidannotations.annotations.EBean; -import org.androidannotations.annotations.EFragment; -import org.androidannotations.annotations.EProvider; -import org.androidannotations.annotations.EReceiver; -import org.androidannotations.annotations.EService; -import org.androidannotations.annotations.EView; -import org.androidannotations.annotations.EViewGroup; -import org.androidannotations.annotations.Extra; -import org.androidannotations.annotations.FragmentArg; -import org.androidannotations.annotations.FragmentById; -import org.androidannotations.annotations.FragmentByTag; -import org.androidannotations.annotations.FromHtml; -import org.androidannotations.annotations.Fullscreen; -import org.androidannotations.annotations.HierarchyViewerSupport; -import org.androidannotations.annotations.HttpsClient; -import org.androidannotations.annotations.InstanceState; -import org.androidannotations.annotations.ItemClick; -import org.androidannotations.annotations.ItemLongClick; -import org.androidannotations.annotations.ItemSelect; -import org.androidannotations.annotations.LongClick; -import org.androidannotations.annotations.NoTitle; -import org.androidannotations.annotations.NonConfigurationInstance; -import org.androidannotations.annotations.OnActivityResult; -import org.androidannotations.annotations.OptionsItem; -import org.androidannotations.annotations.OptionsMenu; -import org.androidannotations.annotations.OptionsMenuItem; -import org.androidannotations.annotations.OrmLiteDao; -import org.androidannotations.annotations.RoboGuice; -import org.androidannotations.annotations.RootContext; -import org.androidannotations.annotations.SeekBarProgressChange; -import org.androidannotations.annotations.SeekBarTouchStart; -import org.androidannotations.annotations.SeekBarTouchStop; -import org.androidannotations.annotations.SystemService; -import org.androidannotations.annotations.TextChange; -import org.androidannotations.annotations.Touch; -import org.androidannotations.annotations.Trace; -import org.androidannotations.annotations.Transactional; -import org.androidannotations.annotations.UiThread; -import org.androidannotations.annotations.ViewById; -import org.androidannotations.annotations.WindowFeature; -import org.androidannotations.annotations.res.AnimationRes; -import org.androidannotations.annotations.res.BooleanRes; -import org.androidannotations.annotations.res.ColorRes; -import org.androidannotations.annotations.res.ColorStateListRes; -import org.androidannotations.annotations.res.DimensionPixelOffsetRes; -import org.androidannotations.annotations.res.DimensionPixelSizeRes; -import org.androidannotations.annotations.res.DimensionRes; -import org.androidannotations.annotations.res.DrawableRes; -import org.androidannotations.annotations.res.HtmlRes; -import org.androidannotations.annotations.res.IntArrayRes; -import org.androidannotations.annotations.res.IntegerRes; -import org.androidannotations.annotations.res.LayoutRes; -import org.androidannotations.annotations.res.MovieRes; -import org.androidannotations.annotations.res.StringArrayRes; -import org.androidannotations.annotations.res.StringRes; -import org.androidannotations.annotations.res.TextArrayRes; -import org.androidannotations.annotations.res.TextRes; -import org.androidannotations.annotations.rest.Accept; -import org.androidannotations.annotations.rest.Delete; -import org.androidannotations.annotations.rest.Get; -import org.androidannotations.annotations.rest.Head; -import org.androidannotations.annotations.rest.Options; -import org.androidannotations.annotations.rest.Post; -import org.androidannotations.annotations.rest.Put; -import org.androidannotations.annotations.rest.Rest; -import org.androidannotations.annotations.rest.RestService; -import org.androidannotations.annotations.sharedpreferences.Pref; -import org.androidannotations.annotations.sharedpreferences.SharedPref; import org.androidannotations.generation.CodeModelGenerator; +import org.androidannotations.handler.AnnotationHandlers; import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.AndroidManifestFinder; import org.androidannotations.helper.Option; import org.androidannotations.helper.TimeStats; -import org.androidannotations.model.AndroidRes; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; import org.androidannotations.model.AnnotationElementsHolder; import org.androidannotations.model.ModelExtractor; -import org.androidannotations.processing.AfterInjectProcessor; -import org.androidannotations.processing.AfterTextChangeProcessor; -import org.androidannotations.processing.AfterViewsProcessor; -import org.androidannotations.processing.AppProcessor; -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; -import org.androidannotations.processing.EApplicationProcessor; -import org.androidannotations.processing.EBeanProcessor; -import org.androidannotations.processing.EFragmentProcessor; -import org.androidannotations.processing.EProviderProcessor; -import org.androidannotations.processing.EReceiverProcessor; -import org.androidannotations.processing.EServiceProcessor; -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; -import org.androidannotations.processing.FromHtmlProcessor; -import org.androidannotations.processing.FullscreenProcessor; -import org.androidannotations.processing.HierarchyViewerSupportProcessor; -import org.androidannotations.processing.HttpsClientProcessor; -import org.androidannotations.processing.InstanceStateProcessor; -import org.androidannotations.processing.ItemClickProcessor; -import org.androidannotations.processing.ItemLongClickProcessor; -import org.androidannotations.processing.ItemSelectedProcessor; -import org.androidannotations.processing.LongClickProcessor; -import org.androidannotations.processing.ModelProcessor; -import org.androidannotations.processing.ModelProcessor.ProcessResult; -import org.androidannotations.processing.NoTitleProcessor; -import org.androidannotations.processing.NonConfigurationInstanceProcessor; -import org.androidannotations.processing.OnActivityResultProcessor; -import org.androidannotations.processing.OptionsItemProcessor; -import org.androidannotations.processing.OptionsMenuItemProcessor; -import org.androidannotations.processing.OptionsMenuProcessor; -import org.androidannotations.processing.OrmLiteDaoProcessor; -import org.androidannotations.processing.PrefProcessor; -import org.androidannotations.processing.ProduceProcessor; -import org.androidannotations.processing.ResProcessor; -import org.androidannotations.processing.RestServiceProcessor; -import org.androidannotations.processing.RoboGuiceProcessor; -import org.androidannotations.processing.RootContextProcessor; -import org.androidannotations.processing.SeekBarProgressChangeProcessor; -import org.androidannotations.processing.SeekBarTouchStartProcessor; -import org.androidannotations.processing.SeekBarTouchStopProcessor; -import org.androidannotations.processing.SharedPrefProcessor; -import org.androidannotations.processing.SubscribeProcessor; -import org.androidannotations.processing.SystemServiceProcessor; -import org.androidannotations.processing.TextChangeProcessor; -import org.androidannotations.processing.TouchProcessor; -import org.androidannotations.processing.TraceProcessor; -import org.androidannotations.processing.TransactionalProcessor; -import org.androidannotations.processing.UiThreadProcessor; -import org.androidannotations.processing.ViewByIdProcessor; -import org.androidannotations.processing.WindowFeatureProcessor; -import org.androidannotations.processing.rest.DeleteProcessor; -import org.androidannotations.processing.rest.GetProcessor; -import org.androidannotations.processing.rest.HeadProcessor; -import org.androidannotations.processing.rest.OptionsProcessor; -import org.androidannotations.processing.rest.PostProcessor; -import org.androidannotations.processing.rest.PutProcessor; -import org.androidannotations.processing.rest.RestImplementationsHolder; -import org.androidannotations.processing.rest.RestProcessor; +import org.androidannotations.process.ModelProcessor; +import org.androidannotations.process.ModelValidator; import org.androidannotations.rclass.AndroidRClassFinder; import org.androidannotations.rclass.CoumpoundRClass; import org.androidannotations.rclass.IRClass; import org.androidannotations.rclass.ProjectRClassFinder; -import org.androidannotations.validation.AfterInjectValidator; -import org.androidannotations.validation.AfterTextChangeValidator; -import org.androidannotations.validation.AfterViewsValidator; -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; -import org.androidannotations.validation.EApplicationValidator; -import org.androidannotations.validation.EBeanValidator; -import org.androidannotations.validation.EFragmentValidator; -import org.androidannotations.validation.EProviderValidator; -import org.androidannotations.validation.EReceiverValidator; -import org.androidannotations.validation.EServiceValidator; -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; -import org.androidannotations.validation.FromHtmlValidator; -import org.androidannotations.validation.FullscreenValidator; -import org.androidannotations.validation.HierarchyViewerSupportValidator; -import org.androidannotations.validation.HttpsClientValidator; -import org.androidannotations.validation.InstanceStateValidator; -import org.androidannotations.validation.ItemClickValidator; -import org.androidannotations.validation.ItemLongClickValidator; -import org.androidannotations.validation.ItemSelectedValidator; -import org.androidannotations.validation.LongClickValidator; -import org.androidannotations.validation.ModelValidator; -import org.androidannotations.validation.NoTitleValidator; -import org.androidannotations.validation.NonConfigurationInstanceValidator; -import org.androidannotations.validation.OnActivityResultValidator; -import org.androidannotations.validation.OptionsItemValidator; -import org.androidannotations.validation.OptionsMenuItemValidator; -import org.androidannotations.validation.OptionsMenuValidator; -import org.androidannotations.validation.OrmLiteDaoValidator; -import org.androidannotations.validation.PrefValidator; -import org.androidannotations.validation.ProduceValidator; -import org.androidannotations.validation.ResValidator; -import org.androidannotations.validation.RestServiceValidator; -import org.androidannotations.validation.RoboGuiceValidator; -import org.androidannotations.validation.RootContextValidator; -import org.androidannotations.validation.RunnableValidator; -import org.androidannotations.validation.SeekBarProgressChangeValidator; -import org.androidannotations.validation.SeekBarTouchStartValidator; -import org.androidannotations.validation.SeekBarTouchStopValidator; -import org.androidannotations.validation.SharedPrefValidator; -import org.androidannotations.validation.SubscribeValidator; -import org.androidannotations.validation.SystemServiceValidator; -import org.androidannotations.validation.TextChangeValidator; -import org.androidannotations.validation.TouchValidator; -import org.androidannotations.validation.TraceValidator; -import org.androidannotations.validation.TransactionalValidator; -import org.androidannotations.validation.ViewByIdValidator; -import org.androidannotations.validation.WindowFeatureValidator; -import org.androidannotations.validation.rest.AcceptValidator; -import org.androidannotations.validation.rest.DeleteValidator; -import org.androidannotations.validation.rest.GetValidator; -import org.androidannotations.validation.rest.HeadValidator; -import org.androidannotations.validation.rest.OptionsValidator; -import org.androidannotations.validation.rest.PostValidator; -import org.androidannotations.validation.rest.PutValidator; -import org.androidannotations.validation.rest.RestValidator; + +import javax.annotation.processing.*; +import javax.lang.model.SourceVersion; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; +import javax.tools.Diagnostic; +import java.io.IOException; +import java.io.PrintWriter; +import java.io.StringWriter; +import java.util.Map; +import java.util.Set; + +import static org.androidannotations.helper.AndroidManifestFinder.ANDROID_MANIFEST_FILE_OPTION; +import static org.androidannotations.helper.ModelConstants.TRACE_OPTION; @SupportedSourceVersion(SourceVersion.RELEASE_6) @SupportedOptions({ TRACE_OPTION, ANDROID_MANIFEST_FILE_OPTION }) public class AndroidAnnotationProcessor extends AbstractProcessor { private final TimeStats timeStats = new TimeStats(); - private Set supportedAnnotationNames; + private AnnotationHandlers annotationHandlers; @Override public synchronized void init(ProcessingEnvironment processingEnv) { super.init(processingEnv); Messager messager = processingEnv.getMessager(); - timeStats.setMessager(messager); - messager.printMessage(Diagnostic.Kind.NOTE, "Starting AndroidAnnotations annotation processing"); + + annotationHandlers = new AnnotationHandlers(processingEnv); } @Override @@ -327,9 +104,11 @@ private void processThrowing(Set annotations, RoundEnviro AndroidSystemServices androidSystemServices = new AndroidSystemServices(); - AnnotationElements validatedModel = validateAnnotations(extractedModel, rClass, androidSystemServices, androidManifest); + annotationHandlers.setAndroidEnvironment(rClass, androidSystemServices, androidManifest); + + AnnotationElements validatedModel = validateAnnotations(extractedModel); - ProcessResult processResult = processAnnotations(validatedModel, rClass, androidSystemServices, androidManifest); + ModelProcessor.ProcessResult processResult = processAnnotations(validatedModel); generateSources(processResult); } @@ -375,14 +154,15 @@ private Option findRClasses(AndroidManifest androidManifest) throws IOE return Option.of(coumpoundRClass); } - private AnnotationElements validateAnnotations(AnnotationElementsHolder extractedModel, IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) { + private AnnotationElements validateAnnotations(AnnotationElementsHolder extractedModel) { timeStats.start("Validate Annotations"); - ModelValidator modelValidator = buildModelValidator(rClass, androidSystemServices, androidManifest); + ModelValidator modelValidator = new ModelValidator(annotationHandlers); AnnotationElements validatedAnnotations = modelValidator.validate(extractedModel); timeStats.stop("Validate Annotations"); return validatedAnnotations; } + /* private ModelValidator buildModelValidator(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) { ModelValidator modelValidator = new ModelValidator(); modelValidator.register(new EApplicationValidator(processingEnv, androidManifest)); @@ -446,7 +226,7 @@ private ModelValidator buildModelValidator(IRClass rClass, AndroidSystemServices /* * Any view injection or listener binding should occur before * AfterViewsValidator - */ + * modelValidator.register(new AfterViewsValidator(processingEnv)); modelValidator.register(new TraceValidator(processingEnv)); modelValidator.register(new SubscribeValidator(processingEnv)); @@ -461,6 +241,7 @@ private ModelValidator buildModelValidator(IRClass rClass, AndroidSystemServices return modelValidator; } + */ private boolean traceActivated() { Map options = processingEnv.getOptions(); @@ -472,14 +253,16 @@ private boolean traceActivated() { } } - private ProcessResult processAnnotations(AnnotationElements validatedModel, IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) throws Exception { + private ModelProcessor.ProcessResult processAnnotations(AnnotationElements validatedModel) throws Exception { timeStats.start("Process Annotations"); - ModelProcessor modelProcessor = buildModelProcessor(rClass, androidSystemServices, androidManifest, validatedModel); - ProcessResult processResult = modelProcessor.process(validatedModel); + annotationHandlers.setValidatedModel(validatedModel); + ModelProcessor modelProcessor = new ModelProcessor(processingEnv, annotationHandlers); + ModelProcessor.ProcessResult processResult = modelProcessor.process(validatedModel); timeStats.stop("Process Annotations"); return processResult; } + /* private ModelProcessor buildModelProcessor(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest, AnnotationElements validatedModel) { ModelProcessor modelProcessor = new ModelProcessor(); modelProcessor.register(new EApplicationProcessor()); @@ -543,7 +326,7 @@ private ModelProcessor buildModelProcessor(IRClass rClass, AndroidSystemServices /* * Any view injection or listener binding should occur before * AfterViewsProcessor - */ + * modelProcessor.register(new AfterViewsProcessor()); if (traceActivated()) { modelProcessor.register(new TraceProcessor()); @@ -559,8 +342,9 @@ private ModelProcessor buildModelProcessor(IRClass rClass, AndroidSystemServices modelProcessor.register(new HierarchyViewerSupportProcessor()); return modelProcessor; } + */ - private void generateSources(ProcessResult processResult) throws IOException { + private void generateSources(ModelProcessor.ProcessResult processResult) throws IOException { timeStats.start("Generate Sources"); Messager messager = processingEnv.getMessager(); messager.printMessage(Diagnostic.Kind.NOTE, "Number of files generated by AndroidAnnotations: " + processResult.codeModel.countArtifacts()); @@ -589,11 +373,13 @@ private String stackTraceToString(Throwable e) { StringWriter writer = new StringWriter(); PrintWriter pw = new PrintWriter(writer); e.printStackTrace(pw); - return writer.toString(); + return writer.toString().replace("\n", ""); } @Override public Set getSupportedAnnotationTypes() { + return annotationHandlers.getSupportedAnnotationTypes(); + /* if (supportedAnnotationNames == null) { Class[] annotationClassesArray = { // // @@ -689,5 +475,6 @@ public Set getSupportedAnnotationTypes() { supportedAnnotationNames = Collections.unmodifiableSet(set); } return supportedAnnotationNames; + */ } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/CodeModelGenerator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/CodeModelGenerator.java index d96ffb7ffd..c2da5da45c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/CodeModelGenerator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/CodeModelGenerator.java @@ -15,14 +15,12 @@ */ package org.androidannotations.generation; -import java.io.IOException; +import com.sun.codemodel.writer.PrologCodeWriter; +import org.androidannotations.process.ModelProcessor; import javax.annotation.processing.Filer; import javax.annotation.processing.Messager; - -import org.androidannotations.processing.ModelProcessor.ProcessResult; - -import com.sun.codemodel.writer.PrologCodeWriter; +import java.io.IOException; public class CodeModelGenerator { @@ -34,7 +32,7 @@ public CodeModelGenerator(Filer filer, Messager messager) { this.messager = messager; } - public void generate(ProcessResult processResult) throws IOException { + public void generate(ModelProcessor.ProcessResult processResult) throws IOException { ApiCodeGenerator apiCodeGenerator = new ApiCodeGenerator(filer); apiCodeGenerator.writeApiClasses(processResult.apiClassesToGenerate, processResult.originatingElements); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandler.java new file mode 100644 index 0000000000..dc76282783 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandler.java @@ -0,0 +1,19 @@ +package org.androidannotations.handler; + +import org.androidannotations.helper.AndroidManifest; +import org.androidannotations.holder.GeneratedClassHolder; +import org.androidannotations.model.AndroidSystemServices; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.rclass.IRClass; + +import javax.lang.model.element.Element; + +public interface AnnotationHandler { + + String getTarget(); + boolean validate(Element element, AnnotationElements validatedElements); + void process(Element element, T holder) throws Exception; + + void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest); + void setValidatedModel(AnnotationElements validatedModel); +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java new file mode 100644 index 0000000000..b9f741b4e6 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -0,0 +1,66 @@ +package org.androidannotations.handler; + +import org.androidannotations.helper.AndroidManifest; +import org.androidannotations.holder.GeneratedClassHolder; +import org.androidannotations.model.AndroidSystemServices; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.rclass.IRClass; + +import javax.annotation.processing.ProcessingEnvironment; +import java.util.*; + +public class AnnotationHandlers { + + private List> annotationHandlers = new ArrayList>(); + private List> generatingAnnotationHandlers = new ArrayList>(); + private List> decoratingAnnotationHandlers = new ArrayList>(); + private Set supportedAnnotationNames; + + public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { + } + + private void add(AnnotationHandler annotationHandler) { + annotationHandlers.add(annotationHandler); + decoratingAnnotationHandlers.add(annotationHandler); + } + + private void add(GeneratingAnnotationHandler annotationHandler) { + annotationHandlers.add(annotationHandler); + generatingAnnotationHandlers.add(annotationHandler); + } + + public List> get() { + return annotationHandlers; + } + + public List> getGenerating() { + return generatingAnnotationHandlers; + } + + public List> getDecorating() { + return decoratingAnnotationHandlers; + } + + public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) { + for (AnnotationHandler annotationHandler : annotationHandlers) { + annotationHandler.setAndroidEnvironment(rClass, androidSystemServices, androidManifest); + } + } + + public void setValidatedModel(AnnotationElements validatedModel) { + for (AnnotationHandler annotationHandler : annotationHandlers) { + annotationHandler.setValidatedModel(validatedModel); + } + } + + public Set getSupportedAnnotationTypes() { + if (supportedAnnotationNames == null) { + Set annotationNames = new HashSet(); + for (AnnotationHandler annotationHandler : annotationHandlers) { + annotationNames.add(annotationHandler.getTarget()); + } + supportedAnnotationNames = Collections.unmodifiableSet(annotationNames); + } + return supportedAnnotationNames; + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BaseAnnotationHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BaseAnnotationHandler.java new file mode 100644 index 0000000000..f14b1abcc1 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BaseAnnotationHandler.java @@ -0,0 +1,54 @@ +package org.androidannotations.handler; + +import org.androidannotations.helper.AndroidManifest; +import org.androidannotations.helper.IdAnnotationHelper; +import org.androidannotations.helper.IdValidatorHelper; +import org.androidannotations.holder.GeneratedClassHolder; +import org.androidannotations.model.AndroidSystemServices; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.rclass.IRClass; + +import javax.annotation.processing.ProcessingEnvironment; + +public abstract class BaseAnnotationHandler implements AnnotationHandler { + + private final String target; + protected ProcessingEnvironment processingEnv; + protected IdValidatorHelper validatorHelper; + protected IRClass rClass; + protected AndroidSystemServices androidSystemServices; + protected AndroidManifest androidManifest; + protected AnnotationElements validatedModel; + + public BaseAnnotationHandler(Class targetClass, ProcessingEnvironment processingEnvironment) { + this(targetClass.getName(), processingEnvironment); + } + + public BaseAnnotationHandler(String target, ProcessingEnvironment processingEnvironment) { + this.target = target; + this.processingEnv = processingEnvironment; + } + + @Override + public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) { + this.rClass = rClass; + this.androidSystemServices = androidSystemServices; + this.androidManifest = androidManifest; + initValidatorHelper(); + } + + private void initValidatorHelper() { + IdAnnotationHelper annotationHelper = new IdAnnotationHelper(processingEnv, target, rClass); + validatorHelper = new IdValidatorHelper(annotationHelper); + } + + @Override + public void setValidatedModel(AnnotationElements validatedModel) { + this.validatedModel = validatedModel; + } + + @Override + public String getTarget() { + return target; + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/GeneratingAnnotationHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/GeneratingAnnotationHandler.java new file mode 100644 index 0000000000..6de3115096 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/GeneratingAnnotationHandler.java @@ -0,0 +1,11 @@ +package org.androidannotations.handler; + +import org.androidannotations.holder.GeneratedClassHolder; +import org.androidannotations.process.ProcessHolder; + +import javax.lang.model.element.TypeElement; + +public interface GeneratingAnnotationHandler extends AnnotationHandler { + + T createGeneratedClassHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception; +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/BaseGeneratedClassHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/BaseGeneratedClassHolder.java new file mode 100644 index 0000000000..6213d60f21 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/BaseGeneratedClassHolder.java @@ -0,0 +1,78 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.*; +import org.androidannotations.helper.ModelConstants; +import org.androidannotations.process.ProcessHolder; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; + +import static com.sun.codemodel.JMod.FINAL; +import static com.sun.codemodel.JMod.PUBLIC; + +public abstract class BaseGeneratedClassHolder implements GeneratedClassHolder { + + protected final ProcessHolder processHolder; + protected JDefinedClass generatedClass; + protected final TypeElement annotatedElement; + + public BaseGeneratedClassHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + this.processHolder = processHolder; + this.annotatedElement = annotatedElement; + setGeneratedClass(); + } + + protected void setGeneratedClass() throws Exception { + String annotatedComponentQualifiedName = annotatedElement.getQualifiedName().toString(); + String subComponentQualifiedName = annotatedComponentQualifiedName + ModelConstants.GENERATION_SUFFIX; + JClass annotatedComponent = codeModel().directClass(annotatedComponentQualifiedName); + generatedClass = codeModel()._class(PUBLIC | FINAL, subComponentQualifiedName, ClassType.CLASS); + generatedClass._extends(annotatedComponent); + } + + @Override + public JDefinedClass getGeneratedClass() { + return generatedClass; + } + + @Override + public TypeElement getAnnotatedElement() { + return annotatedElement; + } + + @Override + public ProcessingEnvironment processingEnvironment() { + return processHolder.processingEnvironment(); + } + + @Override + public ProcessHolder.Classes classes() { + return processHolder.classes(); + } + + @Override + public JCodeModel codeModel() { + return processHolder.codeModel(); + } + + @Override + public JClass refClass(String fullyQualifiedClassName) { + return processHolder.refClass(fullyQualifiedClassName); + } + + @Override + public JClass refClass(Class clazz) { + return processHolder.refClass(clazz); + } + + @Override + public JDefinedClass definedClass(String fullyQualifiedClassName) { + return processHolder.definedClass(fullyQualifiedClassName); + } + + @Override + public void generateApiClass(Element originatingElement, Class apiClass) { + processHolder.generateApiClass(originatingElement, apiClass); + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java new file mode 100644 index 0000000000..57012d567c --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java @@ -0,0 +1,37 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JMethod; +import org.androidannotations.process.ProcessHolder; + +import javax.lang.model.element.TypeElement; + +public abstract class EComponentHolder extends BaseGeneratedClassHolder { + + + protected JExpression contextRef; + protected JMethod init; + + public EComponentHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + super(processHolder, annotatedElement); + } + + public JExpression getContextRef() { + if (contextRef == null) { + setContextRef(); + } + return contextRef; + } + + protected abstract void setContextRef(); + + public JMethod getInit() { + if (init == null) { + setInit(); + } + return init; + } + + protected abstract void setInit(); + +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/GeneratedClassHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/GeneratedClassHolder.java new file mode 100644 index 0000000000..9b1b85bbc7 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/GeneratedClassHolder.java @@ -0,0 +1,23 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.JClass; +import com.sun.codemodel.JCodeModel; +import com.sun.codemodel.JDefinedClass; +import org.androidannotations.process.ProcessHolder; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; + +public interface GeneratedClassHolder { + JDefinedClass getGeneratedClass(); + TypeElement getAnnotatedElement(); + + public ProcessingEnvironment processingEnvironment(); + public ProcessHolder.Classes classes(); + public JCodeModel codeModel(); + public JClass refClass(String fullyQualifiedClassName); + public JClass refClass(Class clazz); + public JDefinedClass definedClass(String fullyQualifiedClassName); + public void generateApiClass(Element originatingElement, Class apiClass); +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ModelProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ModelProcessor.java new file mode 100644 index 0000000000..e30a5b8214 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ModelProcessor.java @@ -0,0 +1,148 @@ +/** + * Copyright (C) 2010-2013 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.process; + +import com.sun.codemodel.JCodeModel; +import org.androidannotations.handler.AnnotationHandler; +import org.androidannotations.handler.AnnotationHandlers; +import org.androidannotations.handler.GeneratingAnnotationHandler; +import org.androidannotations.holder.GeneratedClassHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.model.AnnotationElements.AnnotatedAndRootElements; +import org.androidannotations.processing.OriginatingElements; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ElementKind; +import javax.lang.model.element.Modifier; +import javax.lang.model.element.TypeElement; +import java.util.Set; + +public class ModelProcessor { + + public static class ProcessResult { + + public final JCodeModel codeModel; + public final OriginatingElements originatingElements; + public final Set> apiClassesToGenerate; + + public ProcessResult(// + JCodeModel codeModel, // + OriginatingElements originatingElements, // + Set> apiClassesToGenerate) { + + this.codeModel = codeModel; + this.originatingElements = originatingElements; + this.apiClassesToGenerate = apiClassesToGenerate; + } + } + + private final ProcessingEnvironment processingEnv; + private final AnnotationHandlers annotationHandlers; + + public ModelProcessor(ProcessingEnvironment processingEnv, AnnotationHandlers annotationHandlers) { + this.processingEnv = processingEnv; + this.annotationHandlers = annotationHandlers; + } + + @SuppressWarnings("unchecked") + public ProcessResult process(AnnotationElements validatedModel) throws Exception { + + ProcessHolder processHolder = new ProcessHolder(processingEnv); + + for (GeneratingAnnotationHandler generatingAnnotationHandler : annotationHandlers.getGenerating()) { + String annotationName = generatingAnnotationHandler.getTarget(); + Set annotatedElements = validatedModel.getRootAnnotatedElements(annotationName); + for (Element annotatedElement : annotatedElements) { + /* + * We do not generate code for abstract classes, because the + * generated classes are final anyway (we do not want anyone to + * extend them). + */ + if (!isAbstractClass(annotatedElement)) { + TypeElement typeElement = (TypeElement) annotatedElement; + GeneratedClassHolder generatedClassHolder = generatingAnnotationHandler.createGeneratedClassHolder(processHolder, typeElement); + processHolder.put(annotatedElement, generatedClassHolder); + generatingAnnotationHandler.process(annotatedElement, generatedClassHolder); + } + } + /* + * We currently do not take into account class annotations from + * ancestors. We should careful design the priority rules first. + */ + } + + for (AnnotationHandler annotationHandler : annotationHandlers.getDecorating()) { + String annotationName = annotationHandler.getTarget(); + + /* + * For ancestors, the annotationHandler manipulates the annotated elements, + * but uses the holder for the root element + */ + Set ancestorAnnotatedElements = validatedModel.getAncestorAnnotatedElements(annotationName); + for (AnnotatedAndRootElements elements : ancestorAnnotatedElements) { + GeneratedClassHolder holder = processHolder.getGeneratedClassHolder(elements.rootTypeElement); + /* + * Annotations coming from ancestors may be applied to root + * elements that are not validated, and therefore not available. + */ + if (holder != null) { + annotationHandler.process(elements.annotatedElement, holder); + } + } + + Set rootAnnotatedElements = validatedModel.getRootAnnotatedElements(annotationName); + + for (Element annotatedElement : rootAnnotatedElements) { + + Element enclosingElement; + if (annotatedElement instanceof TypeElement) { + enclosingElement = annotatedElement; + } else { + enclosingElement = annotatedElement.getEnclosingElement(); + } + + /* + * We do not generate code for elements belonging to abstract + * classes, because the generated classes are final anyway + */ + if (!isAbstractClass(enclosingElement)) { + GeneratedClassHolder holder = processHolder.getGeneratedClassHolder(enclosingElement); + annotationHandler.process(annotatedElement, holder); + } + } + + } + + return new ProcessResult(// + processHolder.codeModel(), // + processHolder.getOriginatingElements(), // + processHolder.getApiClassesToGenerate()); + } + + + + private boolean isAbstractClass(Element annotatedElement) { + if (annotatedElement instanceof TypeElement) { + TypeElement typeElement = (TypeElement) annotatedElement; + + return typeElement.getKind() == ElementKind.CLASS && typeElement.getModifiers().contains(Modifier.ABSTRACT); + } else { + return false; + } + } + +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ModelValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ModelValidator.java new file mode 100644 index 0000000000..ed1957c76d --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ModelValidator.java @@ -0,0 +1,62 @@ +/** + * Copyright (C) 2010-2013 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.process; + +import org.androidannotations.handler.AnnotationHandler; +import org.androidannotations.handler.AnnotationHandlers; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.model.AnnotationElementsHolder; + +import javax.lang.model.element.Element; +import java.util.HashSet; +import java.util.Set; + +public class ModelValidator { + + private AnnotationHandlers annotationHandlers; + + public ModelValidator(AnnotationHandlers annotationHandlers) { + this.annotationHandlers = annotationHandlers; + } + + public AnnotationElements validate(AnnotationElementsHolder extractedModel) { + + /* + * We currently do not validate the elements on the ancestors, assuming + * they've already been validated. This also means some checks such as + * unique ids might not be check all situations. + */ + AnnotationElementsHolder validatedElements = extractedModel.validatingHolder(); + + for (AnnotationHandler annotationHandler : annotationHandlers.get()) { + String annotationName = annotationHandler.getTarget(); + + Set annotatedElements = extractedModel.getRootAnnotatedElements(annotationName); + + Set validatedAnnotatedElements = new HashSet(); + + validatedElements.putRootAnnotatedElements(annotationName, validatedAnnotatedElements); + + for (Element annotatedElement : annotatedElements) { + if (annotationHandler.validate(annotatedElement, validatedElements)) { + validatedAnnotatedElements.add(annotatedElement); + } + } + } + return validatedElements; + } + +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ProcessHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ProcessHolder.java new file mode 100644 index 0000000000..abbe15dfa6 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ProcessHolder.java @@ -0,0 +1,258 @@ +/** + * Copyright (C) 2010-2013 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.process; + +import com.sun.codemodel.JClass; +import com.sun.codemodel.JClassAlreadyExistsException; +import com.sun.codemodel.JCodeModel; +import com.sun.codemodel.JDefinedClass; +import org.androidannotations.helper.CanonicalNameConstants; +import org.androidannotations.holder.GeneratedClassHolder; +import org.androidannotations.processing.OriginatingElements; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import java.io.FileInputStream; +import java.io.InputStream; +import java.io.Serializable; +import java.sql.SQLException; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.Set; + +public class ProcessHolder { + + public class Classes { + + /* + * Java + */ + public final JClass RUNTIME_EXCEPTION = refClass(RuntimeException.class); + public final JClass EXCEPTION = refClass(Exception.class); + public final JClass CHAR_SEQUENCE = refClass(CharSequence.class); + public final JClass CLASS_CAST_EXCEPTION = refClass(ClassCastException.class); + public final JClass SERIALIZABLE = refClass(Serializable.class); + public final JClass STRING = refClass(String.class); + public final JClass SYSTEM = refClass(System.class); + public final JClass INPUT_STREAM = refClass(InputStream.class); + public final JClass FILE_INPUT_STREAM = refClass(FileInputStream.class); + public final JClass SQL_EXCEPTION = refClass(SQLException.class); + + /* + * Android + */ + public final JClass LOG = refClass(CanonicalNameConstants.LOG); + public final JClass BUNDLE = refClass(CanonicalNameConstants.BUNDLE); + public final JClass ACTIVITY = refClass(CanonicalNameConstants.ACTIVITY); + public final JClass EDITABLE = refClass(CanonicalNameConstants.EDITABLE); + public final JClass TEXT_WATCHER = refClass(CanonicalNameConstants.TEXT_WATCHER); + 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); + public final JClass INTENT = refClass(CanonicalNameConstants.INTENT); + public final JClass COMPONENT_NAME = refClass(CanonicalNameConstants.COMPONENT_NAME); + public final JClass VIEW_GROUP = refClass(CanonicalNameConstants.VIEW_GROUP); + public final JClass LAYOUT_INFLATER = refClass(CanonicalNameConstants.LAYOUT_INFLATER); + public final JClass FRAGMENT_ACTIVITY = refClass(CanonicalNameConstants.FRAGMENT_ACTIVITY); + public final JClass FRAGMENT = refClass(CanonicalNameConstants.FRAGMENT); + public final JClass SUPPORT_V4_FRAGMENT = refClass(CanonicalNameConstants.SUPPORT_V4_FRAGMENT); + public final JClass HTML = refClass(CanonicalNameConstants.HTML); + public final JClass WINDOW_MANAGER_LAYOUT_PARAMS = refClass(CanonicalNameConstants.WINDOW_MANAGER_LAYOUT_PARAMS); + public final JClass ADAPTER_VIEW = refClass(CanonicalNameConstants.ADAPTER_VIEW); + 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 WINDOW = refClass(CanonicalNameConstants.WINDOW); + public final JClass MENU_ITEM = refClass(CanonicalNameConstants.MENU_ITEM); + public final JClass MENU_INFLATER = refClass(CanonicalNameConstants.MENU_INFLATER); + public final JClass MENU = refClass(CanonicalNameConstants.MENU); + public final JClass ANIMATION_UTILS = refClass(CanonicalNameConstants.ANIMATION_UTILS); + 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 HANDLER = refClass(CanonicalNameConstants.HANDLER); + public final JClass KEY_STORE = refClass(CanonicalNameConstants.KEY_STORE); + public final JClass VIEW_SERVER = refClass(CanonicalNameConstants.VIEW_SERVER); + public final JClass PARCELABLE = refClass(CanonicalNameConstants.PARCELABLE); + + /* + * Sherlock + */ + public final JClass SHERLOCK_MENU = refClass(CanonicalNameConstants.SHERLOCK_MENU); + public final JClass SHERLOCK_MENU_ITEM = refClass(CanonicalNameConstants.SHERLOCK_MENU_ITEM); + public final JClass SHERLOCK_MENU_INFLATER = refClass(CanonicalNameConstants.SHERLOCK_MENU_INFLATER); + + /* + * HoloEverywhre + */ + public final JClass HOLO_EVERYWHERE_LAYOUT_INFLATER = refClass(CanonicalNameConstants.HOLO_EVERYWHERE_LAYOUT_INFLATER); + + /* + * RoboGuice + */ + public final JClass INJECTOR_PROVIDER = refClass(CanonicalNameConstants.INJECTOR_PROVIDER); + public final JClass INJECTOR = refClass(CanonicalNameConstants.INJECTOR); + public final JClass ON_RESTART_EVENT = refClass(CanonicalNameConstants.ON_RESTART_EVENT); + public final JClass ON_START_EVENT = refClass(CanonicalNameConstants.ON_START_EVENT); + public final JClass ON_RESUME_EVENT = refClass(CanonicalNameConstants.ON_RESUME_EVENT); + public final JClass ON_PAUSE_EVENT = refClass(CanonicalNameConstants.ON_PAUSE_EVENT); + public final JClass ON_NEW_INTENT_EVENT = refClass(CanonicalNameConstants.ON_NEW_INTENT_EVENT); + public final JClass EVENT_MANAGER = refClass(CanonicalNameConstants.EVENT_MANAGER); + public final JClass CONTEXT_SCOPE = refClass(CanonicalNameConstants.CONTEXT_SCOPE); + public final JClass INJECT = refClass(CanonicalNameConstants.INJECT); + public final JClass ON_STOP_EVENT = refClass(CanonicalNameConstants.ON_STOP_EVENT); + public final JClass ON_DESTROY_EVENT = refClass(CanonicalNameConstants.ON_DESTROY_EVENT); + public final JClass ON_CONFIGURATION_CHANGED_EVENT = refClass(CanonicalNameConstants.ON_CONFIGURATION_CHANGED_EVENT); + public final JClass ON_CONTENT_CHANGED_EVENT = refClass(CanonicalNameConstants.ON_CONTENT_CHANGED_EVENT); + public final JClass ON_ACTIVITY_RESULT_EVENT = refClass(CanonicalNameConstants.ON_ACTIVITY_RESULT_EVENT); + public final JClass ON_CONTENT_VIEW_AVAILABLE_EVENT = refClass(CanonicalNameConstants.ON_CONTENT_VIEW_AVAILABLE_EVENT); + public final JClass ON_CREATE_EVENT = refClass(CanonicalNameConstants.ON_CREATE_EVENT); + + /* + * OrmLite + */ + public final JClass CONNECTION_SOURCE = refClass(CanonicalNameConstants.CONNECTION_SOURCE); + public final JClass OPEN_HELPER_MANAGER = refClass(CanonicalNameConstants.OPEN_HELPER_MANAGER); + public final JClass DAO_MANAGER = refClass(CanonicalNameConstants.DAO_MANAGER); + + /* + * HttpClient + */ + public final JClass CLIENT_CONNECTION_MANAGER = refClass(CanonicalNameConstants.CLIENT_CONNECTION_MANAGER); + public final JClass DEFAULT_HTTP_CLIENT = refClass(CanonicalNameConstants.DEFAULT_HTTP_CLIENT); + public final JClass SSL_SOCKET_FACTORY = refClass(CanonicalNameConstants.SSL_SOCKET_FACTORY); + public final JClass SCHEME = refClass(CanonicalNameConstants.SCHEME); + public final JClass SCHEME_REGISTRY = refClass(CanonicalNameConstants.SCHEME_REGISTRY); + public final JClass SINGLE_CLIENT_CONN_MANAGER = refClass(CanonicalNameConstants.SINGLE_CLIENT_CONN_MANAGER); + + } + + private final Map generatedClassHolders = new HashMap(); + + private final ProcessingEnvironment processingEnvironment; + + private final JCodeModel codeModel; + + private final Map loadedClasses = new HashMap(); + + private final Classes classes; + + private final Set> apiClassesToGenerate = new HashSet>(); + + private final OriginatingElements originatingElements = new OriginatingElements(); + + public ProcessHolder(ProcessingEnvironment processingEnvironment) { + this.processingEnvironment = processingEnvironment; + this.codeModel = new JCodeModel(); + classes = new Classes(); + refClass(CanonicalNameConstants.STRING); + preloadJavaLangClasses(); + } + + private void preloadJavaLangClasses() { + loadedClasses.put(String.class.getName(), refClass(String.class)); + loadedClasses.put(Object.class.getName(), refClass(Object.class)); + } + + public void put(Element element, GeneratedClassHolder generatedClassHolder) { + + JDefinedClass generatedClass = generatedClassHolder.getGeneratedClass(); + + String qualifiedName = generatedClass.fullName(); + + originatingElements.add(qualifiedName, element); + + generatedClassHolders.put(element, generatedClassHolder); + } + + public GeneratedClassHolder getGeneratedClassHolder(Element element) { + return generatedClassHolders.get(element); + } + + public JClass refClass(Class clazz) { + return codeModel.ref(clazz); + } + + public JClass refClass(String fullyQualifiedClassName) { + + int arrayCounter = 0; + while (fullyQualifiedClassName.endsWith("[]")) { + arrayCounter++; + fullyQualifiedClassName = fullyQualifiedClassName.substring(0, fullyQualifiedClassName.length() - 2); + } + + JClass refClass = loadedClasses.get(fullyQualifiedClassName); + + if (refClass == null) { + refClass = codeModel.directClass(fullyQualifiedClassName); + loadedClasses.put(fullyQualifiedClassName, refClass); + } + + for (int i = 0; i < arrayCounter; i++) { + refClass = refClass.array(); + } + + return refClass; + } + + public JDefinedClass definedClass(String fullyQualifiedClassName) { + JDefinedClass refClass = (JDefinedClass) loadedClasses.get(fullyQualifiedClassName); + if (refClass == null) { + try { + refClass = codeModel._class(fullyQualifiedClassName); + } catch (JClassAlreadyExistsException e) { + refClass = (JDefinedClass) refClass(fullyQualifiedClassName); + } + loadedClasses.put(fullyQualifiedClassName, refClass); + } + return refClass; + } + + public ProcessingEnvironment processingEnvironment() { + return processingEnvironment; + } + + public JCodeModel codeModel() { + return codeModel; + } + + public Classes classes() { + return classes; + } + + public OriginatingElements getOriginatingElements() { + return originatingElements; + } + + public Set> getApiClassesToGenerate() { + return apiClassesToGenerate; + } + + public void generateApiClass(Element originatingElement, Class apiClass) { + originatingElements.add(apiClass.getCanonicalName(), originatingElement); + apiClassesToGenerate.add(apiClass); + } +} From 71db357a2f4cf318bfe4b411704d5a8dc0bda119 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Wed, 22 May 2013 16:53:30 +0200 Subject: [PATCH 02/86] Implement EBeanHandler --- .../handler/AnnotationHandlers.java | 2 + .../handler/EBeanHandler.java | 49 +++++++++ .../holder/EBeanHolder.java | 99 +++++++++++++++++++ 3 files changed, 150 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EBeanHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index b9f741b4e6..464c0d308b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -16,7 +16,9 @@ public class AnnotationHandlers { private List> decoratingAnnotationHandlers = new ArrayList>(); private Set supportedAnnotationNames; + @SuppressWarnings("unchecked") public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { + add(new EBeanHandler(processingEnvironment)); } private void add(AnnotationHandler annotationHandler) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EBeanHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EBeanHandler.java new file mode 100644 index 0000000000..9958c2f367 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EBeanHandler.java @@ -0,0 +1,49 @@ +package org.androidannotations.handler; + +import org.androidannotations.annotations.EBean; +import org.androidannotations.holder.EBeanHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.ProcessHolder; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; + +public class EBeanHandler extends BaseAnnotationHandler implements GeneratingAnnotationHandler { + + public EBeanHandler(ProcessingEnvironment processingEnvironment) { + super(EBean.class, processingEnvironment); + } + + @Override + public EBeanHolder createGeneratedClassHolder(ProcessHolder processHolder, TypeElement annotatedComponent) throws Exception{ + return new EBeanHolder(processHolder, annotatedComponent); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.isNotFinal(element, valid); + + validatorHelper.isNotPrivate(element, valid); + + validatorHelper.hasEmptyOrContextConstructor(element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EBeanHolder holder) { + EBean eBeanAnnotation = element.getAnnotation(EBean.class); + EBean.Scope eBeanScope = eBeanAnnotation.scope(); + boolean hasSingletonScope = eBeanScope == EBean.Scope.Singleton; + + holder.createFactoryMethod(hasSingletonScope); + + if (!hasSingletonScope) { + holder.createRebindMethod(); + } + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java new file mode 100644 index 0000000000..d6a2a561cd --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java @@ -0,0 +1,99 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JFieldVar; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JVar; +import org.androidannotations.helper.ViewNotifierHelper; +import org.androidannotations.process.ProcessHolder; + +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.TypeElement; +import javax.lang.model.util.ElementFilter; +import java.util.List; + +import static com.sun.codemodel.JExpr._new; +import static com.sun.codemodel.JExpr._null; +import static com.sun.codemodel.JMod.*; +import static org.androidannotations.helper.ModelConstants.GENERATION_SUFFIX; + +public class EBeanHolder extends EComponentHolder { + + public static final String GET_INSTANCE_METHOD_NAME = "getInstance" + GENERATION_SUFFIX; + + private ViewNotifierHelper viewNotifierHelper; + private JFieldVar contextField; + private JMethod constructor; + + public EBeanHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + super(processHolder, annotatedElement); + viewNotifierHelper = new ViewNotifierHelper(this); + setConstructor(); + } + + private void setConstructor() { + constructor = generatedClass.constructor(PRIVATE); + JVar constructorContextParam = constructor.param(classes().CONTEXT, "context"); + JBlock constructorBody = constructor.body(); + List constructors = ElementFilter.constructorsIn(annotatedElement.getEnclosedElements()); + ExecutableElement superConstructor = constructors.get(0); + if (superConstructor.getParameters().size() == 1) { + constructorBody.invoke("super").arg(constructorContextParam); + } + constructorBody.assign(getContextField(), constructorContextParam); + } + + public JFieldVar getContextField() { + if (contextField == null) { + contextField = generatedClass.field(PRIVATE, classes().CONTEXT, "context_"); + } + return contextField; + } + + @Override + protected void setContextRef() { + contextRef = getContextField(); + } + protected void setInit() { + init = generatedClass.method(PRIVATE, processHolder.codeModel().VOID, "init_"); + JBlock constructorBody = constructor.body(); + constructorBody.invoke(init); + } + + public void createFactoryMethod(boolean hasSingletonScope) { + + JMethod factoryMethod = generatedClass.method(PUBLIC | STATIC, generatedClass, GET_INSTANCE_METHOD_NAME); + + JVar factoryMethodContextParam = factoryMethod.param(classes().CONTEXT, "context"); + + JBlock factoryMethodBody = factoryMethod.body(); + + /* + * Singletons are bound to the application context + */ + if (hasSingletonScope) { + + JFieldVar instanceField = generatedClass.field(PRIVATE | STATIC, generatedClass, "instance_"); + + JBlock creationBlock = factoryMethodBody // + ._if(instanceField.eq(_null())) // + ._then(); + JVar previousNotifier = viewNotifierHelper.replacePreviousNotifierWithNull(creationBlock); + creationBlock.assign(instanceField, _new(generatedClass).arg(factoryMethodContextParam.invoke("getApplicationContext"))); + viewNotifierHelper.resetPreviousNotifier(creationBlock, previousNotifier); + + factoryMethodBody._return(instanceField); + } else { + factoryMethodBody._return(_new(generatedClass).arg(factoryMethodContextParam)); + } + } + + public void createRebindMethod() { + JMethod rebindMethod = generatedClass.method(PUBLIC, codeModel().VOID, "rebind"); + JVar contextParam = rebindMethod.param(classes().CONTEXT, "context"); + JBlock body = rebindMethod.body(); + body.assign(getContextField(), contextParam); + body.invoke(getInit()); + } + +} From 8c359bfe97ff63069ce375a79bed45c7c4f97631 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Tue, 4 Jun 2013 23:27:41 +0200 Subject: [PATCH 03/86] Implement EActivityHandler --- .../handler/AnnotationHandlers.java | 3 +- .../handler/EActivityHandler.java | 65 ++++++ .../helper/ActivityIntentBuilder.java | 38 ++++ .../helper/AnnotationHelper.java | 17 ++ .../helper/GreenDroidHelper.java | 50 +++++ .../helper/IntentBuilder.java | 63 ++++++ .../helper/ServiceIntentBuilder.java | 32 +++ .../helper/ViewNotifierHelper.java | 59 +++++ .../holder/EActivityHolder.java | 206 ++++++++++++++++++ .../holder/HasIntentBuilder.java | 13 ++ .../rclass/RInnerClass.java | 29 ++- 11 files changed, 564 insertions(+), 11 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EActivityHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ActivityIntentBuilder.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/GreenDroidHelper.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IntentBuilder.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ServiceIntentBuilder.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ViewNotifierHelper.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasIntentBuilder.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 464c0d308b..625e4e7185 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -18,7 +18,8 @@ public class AnnotationHandlers { @SuppressWarnings("unchecked") public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { - add(new EBeanHandler(processingEnvironment)); + add(new EActivityHandler(processingEnvironment)); + add(new EBeanHandler(processingEnvironment)); } private void add(AnnotationHandler annotationHandler) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EActivityHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EActivityHandler.java new file mode 100644 index 0000000000..421d7d1322 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EActivityHandler.java @@ -0,0 +1,65 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JFieldRef; +import com.sun.codemodel.JMethod; +import org.androidannotations.annotations.EActivity; +import org.androidannotations.helper.AnnotationHelper; +import org.androidannotations.helper.IdValidatorHelper; +import org.androidannotations.holder.EActivityHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.ProcessHolder; +import org.androidannotations.rclass.IRClass; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; +import java.util.List; + +public class EActivityHandler extends BaseAnnotationHandler implements GeneratingAnnotationHandler { + + private AnnotationHelper annotationHelper; + + public EActivityHandler(ProcessingEnvironment processingEnvironment) { + super(EActivity.class, processingEnvironment); + annotationHelper = new AnnotationHelper(processingEnv); + } + + @Override + public EActivityHolder createGeneratedClassHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + return new EActivityHolder(processHolder, annotatedElement); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.extendsActivity(element, valid); + + validatorHelper.resIdsExist(element, IRClass.Res.LAYOUT, IdValidatorHelper.FallbackStrategy.ALLOW_NO_RES_ID, valid); + + validatorHelper.isNotFinal(element, valid); + + validatorHelper.componentRegistered(element, androidManifest, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EActivityHolder holder) { + + List fieldRefs = annotationHelper.extractAnnotationFieldRefs(holder, element, getTarget(), rClass.get(IRClass.Res.LAYOUT), false); + + JFieldRef contentViewId = null; + if (fieldRefs.size() == 1) { + contentViewId = fieldRefs.get(0); + } + + if (contentViewId != null) { + JBlock onCreateBody = holder.getOnCreate().body(); + JMethod setContentView = holder.getSetContentViewLayout(); + onCreateBody.invoke(setContentView).arg(contentViewId); + } + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ActivityIntentBuilder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ActivityIntentBuilder.java new file mode 100644 index 0000000000..36ed5c57c3 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ActivityIntentBuilder.java @@ -0,0 +1,38 @@ +package org.androidannotations.helper; + +import com.sun.codemodel.*; +import org.androidannotations.holder.HasIntentBuilder; + +import static com.sun.codemodel.JMod.PUBLIC; + +public class ActivityIntentBuilder extends IntentBuilder { + + public ActivityIntentBuilder(HasIntentBuilder holder) { + super(holder); + } + + @Override + public void build() throws JClassAlreadyExistsException { + super.build(); + createStart(); + createStartForResult(); + } + + private void createStart() { + JMethod method = holder.getIntentBuilderClass().method(PUBLIC, holder.codeModel().VOID, "start"); + method.body().invoke(contextField, "startActivity").arg(holder.getIntentField()); + } + + private void createStartForResult() { + JMethod method = holder.getIntentBuilderClass().method(PUBLIC, holder.codeModel().VOID, "startForResult"); + JVar requestCode = method.param(holder.codeModel().INT, "requestCode"); + + JBlock body = method.body(); + JClass activityClass = holder.classes().ACTIVITY; + JConditional condition = body._if(contextField._instanceof(activityClass)); + condition._then() // + .invoke(JExpr.cast(activityClass, contextField), "startActivityForResult").arg(holder.getIntentField()).arg(requestCode); + condition._else() // + .invoke(contextField, "startActivity").arg(holder.getIntentField()); + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AnnotationHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AnnotationHelper.java index 9530be82b6..818ecb7bc2 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AnnotationHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AnnotationHelper.java @@ -43,6 +43,7 @@ import org.androidannotations.annotations.OnActivityResult; import org.androidannotations.annotations.OptionsItem; import org.androidannotations.annotations.ResId; +import org.androidannotations.holder.GeneratedClassHolder; import org.androidannotations.processing.EBeanHolder; import org.androidannotations.rclass.IRInnerClass; import org.androidannotations.rclass.RInnerClass; @@ -150,6 +151,22 @@ public Types getTypeUtils() { return processingEnv.getTypeUtils(); } + /** + * Returns a list of {@link JFieldRef} linking to the R class, based on the + * given annotation + * + * @see #extractAnnotationResources(Element, Class, IRInnerClass, boolean) + */ + public List extractAnnotationFieldRefs(GeneratedClassHolder holder, Element element, String annotationName, IRInnerClass rInnerClass, boolean useElementName) { + List fieldRefs = new ArrayList(); + + for (String refQualifiedName : extractAnnotationResources(element, annotationName, rInnerClass, useElementName)) { + fieldRefs.add(RInnerClass.extractIdStaticRef(holder, refQualifiedName)); + } + + return fieldRefs; + } + /** * Returns a list of {@link JFieldRef} linking to the R class, based on the * given annotation diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/GreenDroidHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/GreenDroidHelper.java new file mode 100644 index 0000000000..a42747bae2 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/GreenDroidHelper.java @@ -0,0 +1,50 @@ +package org.androidannotations.helper; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.TypeElement; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class GreenDroidHelper { + + public static final String GREENDROID_GD_ACTIVITY_CLASS = "greendroid.app.GDActivity"; + + public static final String GREENDROID_GD_LIST_ACTIVITY_CLASS = "greendroid.app.GDListActivity"; + + public static final String GREENDROID_GD_TAB_ACTIVITY_CLASS = "greendroid.app.GDTabActivity"; + + public static final String GREENDROID_GD_MAP_ACTIVITY_CLASS = "greendroid.app.GDMapActivity"; + + public static final List GREENDROID_ACTIVITIES_LIST_CLASS = Arrays.asList(new String[]{ // + GREENDROID_GD_ACTIVITY_CLASS, // + GREENDROID_GD_LIST_ACTIVITY_CLASS, // + GREENDROID_GD_TAB_ACTIVITY_CLASS, // + GREENDROID_GD_MAP_ACTIVITY_CLASS // + }); + + private ProcessingEnvironment processingEnv; + private List greendroidActivityElements; + + public GreenDroidHelper(ProcessingEnvironment processingEnv) { + this.processingEnv = processingEnv; + AnnotationHelper annotationHelper = new AnnotationHelper(processingEnv); + + greendroidActivityElements = new ArrayList(); + for (String greendroidActivityName : GREENDROID_ACTIVITIES_LIST_CLASS) { + TypeElement typeElement = annotationHelper.typeElementFromQualifiedName(greendroidActivityName); + if (typeElement != null) { + greendroidActivityElements.add(typeElement); + } + } + } + + public boolean usesGreenDroid(TypeElement annotatedElement) { + for (TypeElement greendroidActivityElement : greendroidActivityElements) { + if (processingEnv.getTypeUtils().isSubtype(annotatedElement.asType(), greendroidActivityElement.asType())) { + return true; + } + } + return false; + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IntentBuilder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IntentBuilder.java new file mode 100644 index 0000000000..93dba017ec --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IntentBuilder.java @@ -0,0 +1,63 @@ +package org.androidannotations.helper; + +import com.sun.codemodel.*; +import org.androidannotations.holder.HasIntentBuilder; + +import static com.sun.codemodel.JExpr._new; +import static com.sun.codemodel.JExpr._this; +import static com.sun.codemodel.JMod.*; + +public class IntentBuilder { + + protected HasIntentBuilder holder; + protected JFieldVar contextField; + protected JClass contextClass; + protected JClass intentClass; + + public IntentBuilder(HasIntentBuilder holder) { + this.holder = holder; + contextClass = holder.classes().CONTEXT; + intentClass = holder.classes().INTENT; + } + + public void build() throws JClassAlreadyExistsException { + createClass(); + createConstructor(); + createGet(); + createFlags(); + createIntent(); + } + + private void createClass() throws JClassAlreadyExistsException { + holder.setIntentBuilderClass(holder.getGeneratedClass()._class(PUBLIC | STATIC, "IntentBuilder_")); + contextField = holder.getIntentBuilderClass().field(PRIVATE, contextClass, "context_"); + holder.setIntentField(holder.getIntentBuilderClass().field(PRIVATE | FINAL, intentClass, "intent_")); + } + + private void createConstructor() { + JMethod constructor = holder.getIntentBuilderClass().constructor(JMod.PUBLIC); + JVar constructorContextParam = constructor.param(contextClass, "context"); + JBlock constructorBody = constructor.body(); + constructorBody.assign(contextField, constructorContextParam); + constructorBody.assign(holder.getIntentField(), _new(intentClass).arg(constructorContextParam).arg(holder.getGeneratedClass().dotclass())); + } + + private void createGet() { + JMethod method = holder.getIntentBuilderClass().method(PUBLIC, intentClass, "get"); + method.body()._return(holder.getIntentField()); + } + + private void createFlags() { + JMethod method = holder.getIntentBuilderClass().method(PUBLIC, holder.getIntentBuilderClass(), "flags"); + JVar flagsParam = method.param(holder.codeModel().INT, "flags"); + JBlock body = method.body(); + body.invoke(holder.getIntentField(), "setFlags").arg(flagsParam); + body._return(_this()); + } + + private void createIntent() { + JMethod method = holder.getGeneratedClass().method(STATIC | PUBLIC, holder.getIntentBuilderClass(), "intent"); + JVar contextParam = method.param(contextClass, "context"); + method.body()._return(_new(holder.getIntentBuilderClass()).arg(contextParam)); + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ServiceIntentBuilder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ServiceIntentBuilder.java new file mode 100644 index 0000000000..da3ccf5f2a --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ServiceIntentBuilder.java @@ -0,0 +1,32 @@ +package org.androidannotations.helper; + +import com.sun.codemodel.JClassAlreadyExistsException; +import com.sun.codemodel.JMethod; +import org.androidannotations.holder.HasIntentBuilder; + +import static com.sun.codemodel.JMod.PUBLIC; + +public class ServiceIntentBuilder extends IntentBuilder { + + public ServiceIntentBuilder(HasIntentBuilder holder) { + super(holder); + } + + @Override + public void build() throws JClassAlreadyExistsException { + super.build(); + createStart(); + createStop(); + } + + private void createStart() { + JMethod method = holder.getIntentBuilderClass().method(PUBLIC, holder.classes().COMPONENT_NAME, "start"); + method.body()._return(contextField.invoke("startService").arg(holder.getIntentField())); + } + + private void createStop() { + JMethod method = holder.getIntentBuilderClass().method(PUBLIC, holder.codeModel().BOOLEAN, "stop"); + method.body()._return(contextField.invoke("stopService").arg(holder.getIntentField())); + } + +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ViewNotifierHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ViewNotifierHelper.java new file mode 100644 index 0000000000..fc2614763d --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ViewNotifierHelper.java @@ -0,0 +1,59 @@ +package org.androidannotations.helper; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JFieldVar; +import com.sun.codemodel.JVar; +import org.androidannotations.api.view.HasViews; +import org.androidannotations.api.view.OnViewChangedNotifier; +import org.androidannotations.holder.EComponentHolder; + +import static com.sun.codemodel.JExpr._new; +import static com.sun.codemodel.JExpr._null; +import static com.sun.codemodel.JExpr._this; +import static com.sun.codemodel.JMod.FINAL; +import static com.sun.codemodel.JMod.PRIVATE; + +public class ViewNotifierHelper { + + private EComponentHolder holder; + private JFieldVar notifier; + + public ViewNotifierHelper(EComponentHolder holder) { + this.holder = holder; + } + + public void invokeViewChanged(JBlock block) { + block.invoke(notifier, "notifyViewChanged").arg(_this()); + } + + public JVar replacePreviousNotifier(JBlock block) { + JClass notifierClass = holder.refClass(OnViewChangedNotifier.class); + if (notifier == null) { + notifier = holder.getGeneratedClass().field(PRIVATE | FINAL, notifierClass, "onViewChangedNotifier_", _new(notifierClass)); + holder.getGeneratedClass()._implements(HasViews.class); + } + JVar previousNotifier = block.decl(notifierClass, "previousNotifier", notifierClass.staticInvoke("replaceNotifier").arg(notifier)); + return previousNotifier; + } + + public JVar replacePreviousNotifierWithNull(JBlock block) { + JClass notifierClass = holder.refClass(OnViewChangedNotifier.class); + JVar previousNotifier = block.decl(notifierClass, "previousNotifier", notifierClass.staticInvoke("replaceNotifier").arg(_null())); + return previousNotifier; + } + + public void resetPreviousNotifier(JBlock block, JVar previousNotifier) { + JClass notifierClass = holder.refClass(OnViewChangedNotifier.class); + block.staticInvoke(notifierClass, "replaceNotifier").arg(previousNotifier); + } + + public void wrapInitWithNotifier() { + JBlock initBlock = holder.getInit().body(); + JVar previousNotifier = replacePreviousNotifier(initBlock); + // TODO: see the effect of this + // initBody = initBody.block(); + resetPreviousNotifier(initBlock, previousNotifier); + } + +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java new file mode 100644 index 0000000000..eca78b7a5c --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java @@ -0,0 +1,206 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.*; +import org.androidannotations.api.SdkVersionHelper; +import org.androidannotations.helper.*; +import org.androidannotations.process.ProcessHolder; + +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.Modifier; +import javax.lang.model.element.TypeElement; +import javax.lang.model.type.TypeKind; +import javax.lang.model.util.ElementFilter; +import java.util.ArrayList; +import java.util.List; + +import static com.sun.codemodel.JExpr._super; +import static com.sun.codemodel.JExpr._this; +import static com.sun.codemodel.JMod.PRIVATE; +import static com.sun.codemodel.JMod.PUBLIC; + +public class EActivityHolder extends EComponentHolder implements HasIntentBuilder { + + private ViewNotifierHelper viewNotifierHelper; + private GreenDroidHelper greenDroidHelper; + private JMethod onCreate; + private JMethod setContentViewLayout; + private JVar initSavedInstanceParam; + private JDefinedClass intentBuilderClass; + private JFieldVar intentField; + + public EActivityHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + super(processHolder, annotatedElement); + viewNotifierHelper = new ViewNotifierHelper(this); + createIntentBuilder(); + handleBackPressed(); + } + + @Override + protected void setContextRef() { + contextRef = _this(); + } + + @Override + protected void setInit() { + init = generatedClass.method(PRIVATE, codeModel().VOID, "init_"); + JClass bundleClass = classes().BUNDLE; + initSavedInstanceParam = init.param(bundleClass, "savedInstanceState"); + getOnCreate(); + } + + public JMethod getOnCreate() { + if (onCreate == null) { + setOnCreate(); + } + return onCreate; + } + + private void setOnCreate() { + onCreate = generatedClass.method(PUBLIC, codeModel().VOID, "onCreate"); + onCreate.annotate(Override.class); + JClass bundleClass = classes().BUNDLE; + JVar onCreateSavedInstanceState = onCreate.param(bundleClass, "savedInstanceState"); + JBlock onCreateBody = onCreate.body(); + JVar previousNotifier = viewNotifierHelper.replacePreviousNotifier(onCreateBody); + onCreateBody.invoke(getInit()).arg(onCreateSavedInstanceState); + onCreateBody.invoke(_super(), onCreate).arg(onCreateSavedInstanceState); + viewNotifierHelper.resetPreviousNotifier(onCreateBody, previousNotifier); + } + + public JMethod getSetContentViewLayout() { + if (setContentViewLayout == null) { + setSetContentView(); + } + return setContentViewLayout; + } + + private void setSetContentView() { + String setContentViewMethodName; + if (usesGreenDroid()) { + setContentViewMethodName = "setActionBarContentView"; + } else { + setContentViewMethodName = "setContentView"; + } + + JClass layoutParamsClass = classes().VIEW_GROUP_LAYOUT_PARAMS; + + setContentViewLayout = setContentViewMethod(setContentViewMethodName, new JType[] { codeModel().INT }, new String[] { "layoutResID" }); + setContentViewMethod(setContentViewMethodName, new JType[] { classes().VIEW, layoutParamsClass }, new String[] { "view", "params" }); + setContentViewMethod(setContentViewMethodName, new JType[] { classes().VIEW }, new String[] { "view" }); + } + + private JMethod setContentViewMethod(String setContentViewMethodName, JType[] paramTypes, String[] paramNames) { + JMethod method = generatedClass.method(JMod.PUBLIC, codeModel().VOID, setContentViewMethodName); + method.annotate(Override.class); + + ArrayList params = new ArrayList(); + for (int i = 0; i < paramTypes.length; i++) { + JVar param = method.param(paramTypes[i], paramNames[i]); + params.add(param); + } + JBlock body = method.body(); + JInvocation superCall = body.invoke(JExpr._super(), method); + for (JVar arg : params) { + superCall.arg(arg); + } + viewNotifierHelper.invokeViewChanged(body); + return method; + } + + public JVar getInitSavedInstanceParam() { + return initSavedInstanceParam; + } + + + private boolean usesGreenDroid() { + if (greenDroidHelper == null) { + greenDroidHelper = new GreenDroidHelper(processingEnvironment()); + } + return greenDroidHelper.usesGreenDroid(annotatedElement); + } + private void createIntentBuilder() throws JClassAlreadyExistsException { + new ActivityIntentBuilder(this).build(); + } + + private void handleBackPressed() { + Element declaredOnBackPressedMethod = getOnBackPressedMethod(annotatedElement); + if (declaredOnBackPressedMethod != null) { + + processHolder.generateApiClass(declaredOnBackPressedMethod, SdkVersionHelper.class); + + JMethod onKeyDownMethod = generatedClass.method(PUBLIC, codeModel().BOOLEAN, "onKeyDown"); + onKeyDownMethod.annotate(Override.class); + JVar keyCodeParam = onKeyDownMethod.param(codeModel().INT, "keyCode"); + JClass keyEventClass = classes().KEY_EVENT; + JVar eventParam = onKeyDownMethod.param(keyEventClass, "event"); + + JClass versionHelperClass = refClass(SdkVersionHelper.class); + + JInvocation sdkInt = versionHelperClass.staticInvoke("getSdkInt"); + + JBlock onKeyDownBody = onKeyDownMethod.body(); + + onKeyDownBody._if( // + sdkInt.lt(JExpr.lit(5)) // + .cand(keyCodeParam.eq(keyEventClass.staticRef("KEYCODE_BACK"))) // + .cand(eventParam.invoke("getRepeatCount").eq(JExpr.lit(0)))) // + ._then() // + .invoke("onBackPressed"); + + onKeyDownBody._return( // + JExpr._super().invoke(onKeyDownMethod) // + .arg(keyCodeParam) // + .arg(eventParam)); + + } + } + + private ExecutableElement getOnBackPressedMethod(TypeElement activityElement) { + + AnnotationHelper annotationHelper = new AnnotationHelper(processingEnvironment()); + + List allMembers = annotationHelper.getElementUtils().getAllMembers(activityElement); + + List activityInheritedMethods = ElementFilter.methodsIn(allMembers); + + for (ExecutableElement activityInheritedMethod : activityInheritedMethods) { + if (isCustomOnBackPressedMethod(activityInheritedMethod)) { + return activityInheritedMethod; + } + } + return null; + } + + private boolean isCustomOnBackPressedMethod(ExecutableElement method) { + TypeElement methodClass = (TypeElement) method.getEnclosingElement(); + boolean methodBelongsToActivityClass = methodClass.getQualifiedName().toString().equals(CanonicalNameConstants.ACTIVITY); + return !methodBelongsToActivityClass // + && method.getSimpleName().toString().equals("onBackPressed") // + && method.getThrownTypes().size() == 0 // + && method.getModifiers().contains(Modifier.PUBLIC) // + && method.getReturnType().getKind().equals(TypeKind.VOID) // + && method.getParameters().size() == 0 // + ; + } + + @Override + public void setIntentBuilderClass(JDefinedClass intentBuilderClass) { + this.intentBuilderClass = intentBuilderClass; + } + + @Override + public JDefinedClass getIntentBuilderClass() { + return intentBuilderClass; + } + + @Override + public void setIntentField(JFieldVar intentField) { + this.intentField = intentField; + } + + @Override + public JFieldVar getIntentField() { + return intentField; + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasIntentBuilder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasIntentBuilder.java new file mode 100644 index 0000000000..603cd5ebd8 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasIntentBuilder.java @@ -0,0 +1,13 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.JDefinedClass; +import com.sun.codemodel.JFieldVar; + +public interface HasIntentBuilder extends GeneratedClassHolder { + + public void setIntentBuilderClass(JDefinedClass intentBuilderClass); + public JDefinedClass getIntentBuilderClass(); + + public void setIntentField(JFieldVar intentField); + public JFieldVar getIntentField(); +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/RInnerClass.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/RInnerClass.java index 0fcaaefb1c..105ff0af70 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/RInnerClass.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/RInnerClass.java @@ -15,22 +15,18 @@ */ package org.androidannotations.rclass; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JFieldRef; +import org.androidannotations.helper.CaseHelper; +import org.androidannotations.holder.GeneratedClassHolder; +import org.androidannotations.processing.EBeanHolder; import javax.lang.model.element.Element; import javax.lang.model.element.TypeElement; import javax.lang.model.element.VariableElement; import javax.lang.model.type.TypeKind; import javax.lang.model.util.ElementFilter; - -import org.androidannotations.helper.CaseHelper; -import org.androidannotations.processing.EBeanHolder; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JFieldRef; +import java.util.*; public class RInnerClass implements IRInnerClass { @@ -115,6 +111,19 @@ public JFieldRef getIdStaticRef(String name, EBeanHolder holder) { return extractIdStaticRef(holder, layoutFieldQualifiedName); } + public static JFieldRef extractIdStaticRef(GeneratedClassHolder holder, String layoutFieldQualifiedName) { + if (layoutFieldQualifiedName != null) { + int fieldSuffix = layoutFieldQualifiedName.lastIndexOf('.'); + String fieldName = layoutFieldQualifiedName.substring(fieldSuffix + 1); + String rInnerClassName = layoutFieldQualifiedName.substring(0, fieldSuffix); + + JClass refClass = holder.refClass(rInnerClassName); + return refClass.staticRef(fieldName); + } else { + return null; + } + } + public static JFieldRef extractIdStaticRef(EBeanHolder holder, String layoutFieldQualifiedName) { if (layoutFieldQualifiedName != null) { int fieldSuffix = layoutFieldQualifiedName.lastIndexOf('.'); From f1b3eb5e803b5f59f65fd603095a740e10dccd87 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 23 May 2013 12:04:45 +0200 Subject: [PATCH 04/86] Implement EApplicationHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/EApplicationHandler.java | 42 ++++++++++++++ .../holder/EApplicationHolder.java | 56 +++++++++++++++++++ 3 files changed, 99 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EApplicationHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EApplicationHolder.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 625e4e7185..02da895242 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -18,6 +18,7 @@ public class AnnotationHandlers { @SuppressWarnings("unchecked") public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { + add(new EApplicationHandler(processingEnvironment)); add(new EActivityHandler(processingEnvironment)); add(new EBeanHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EApplicationHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EApplicationHandler.java new file mode 100644 index 0000000000..e661a81ab5 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EApplicationHandler.java @@ -0,0 +1,42 @@ +package org.androidannotations.handler; + +import org.androidannotations.annotations.EApplication; +import org.androidannotations.holder.EApplicationHolder; +import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.ProcessHolder; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; + +public class EApplicationHandler extends BaseAnnotationHandler implements GeneratingAnnotationHandler { + + public EApplicationHandler(ProcessingEnvironment processingEnvironment) { + super(EApplication.class, processingEnvironment); + } + + @Override + public EApplicationHolder createGeneratedClassHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + return new EApplicationHolder(processHolder, annotatedElement); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.extendsApplication(element, valid); + + validatorHelper.isNotFinal(element, valid); + + validatorHelper.applicationRegistered(element, androidManifest, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EApplicationHolder holder) { + /* Do nothing */ + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EApplicationHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EApplicationHolder.java new file mode 100644 index 0000000000..5cc57ae9d1 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EApplicationHolder.java @@ -0,0 +1,56 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.*; +import org.androidannotations.process.ProcessHolder; + +import javax.lang.model.element.TypeElement; + +import static com.sun.codemodel.JExpr._super; +import static com.sun.codemodel.JExpr._this; +import static com.sun.codemodel.JMod.*; + +public class EApplicationHolder extends EComponentHolder { + + public static final String GET_APPLICATION_INSTANCE = "getInstance"; + + private JFieldVar staticInstanceField; + + public EApplicationHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + super(processHolder, annotatedElement); + createSingleton(); + createOnCreate(); + } + + private void createSingleton() { + JClass annotatedComponent = generatedClass._extends(); + + staticInstanceField = generatedClass.field(PRIVATE | STATIC, annotatedComponent, "INSTANCE_"); + // Static singleton getter and setter + JMethod getInstance = generatedClass.method(PUBLIC | STATIC, annotatedComponent, GET_APPLICATION_INSTANCE); + getInstance.body()._return(staticInstanceField); + + JMethod setInstance = generatedClass.method(PUBLIC | STATIC, codeModel().VOID, "setForTesting"); + setInstance.javadoc().append("Visible for testing purposes"); + JVar applicationParam = setInstance.param(annotatedComponent, "application"); + setInstance.body().assign(staticInstanceField, applicationParam); + } + + private void createOnCreate() { + JMethod onCreate = generatedClass.method(PUBLIC, codeModel().VOID, "onCreate"); + onCreate.annotate(Override.class); + JBlock onCreateBody = onCreate.body(); + onCreateBody.assign(staticInstanceField, _this()); + onCreateBody.invoke(getInit()); + onCreateBody.invoke(_super(), onCreate); + } + + @Override + protected void setContextRef() { + contextRef = JExpr._this(); + } + + @Override + protected void setInit() { + init = generatedClass.method(PRIVATE, codeModel().VOID, "init_"); + } +} From 03620f9372837b1f422ce88e4a8d8037f474378c Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 23 May 2013 14:33:23 +0200 Subject: [PATCH 05/86] Implement EFragmentHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/EFragmentHandler.java | 73 ++++++++ .../helper/HoloEverywhereHelper.java | 31 ++++ .../helper/IdAnnotationHelper.java | 25 ++- .../holder/EFragmentHolder.java | 165 ++++++++++++++++++ 5 files changed, 289 insertions(+), 6 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EFragmentHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/HoloEverywhereHelper.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 02da895242..1d679d6022 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -20,6 +20,7 @@ public class AnnotationHandlers { public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new EApplicationHandler(processingEnvironment)); add(new EActivityHandler(processingEnvironment)); + add(new EFragmentHandler(processingEnvironment)); add(new EBeanHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EFragmentHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EFragmentHandler.java new file mode 100644 index 0000000000..6e4d2184b0 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EFragmentHandler.java @@ -0,0 +1,73 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JFieldRef; +import com.sun.codemodel.JFieldVar; +import com.sun.codemodel.JVar; +import org.androidannotations.annotations.EFragment; +import org.androidannotations.helper.IdAnnotationHelper; +import org.androidannotations.helper.IdValidatorHelper; +import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.holder.EFragmentHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.ProcessHolder; +import org.androidannotations.rclass.IRClass; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; + +import static com.sun.codemodel.JExpr.FALSE; +import static com.sun.codemodel.JExpr._null; + +public class EFragmentHandler extends BaseAnnotationHandler implements GeneratingAnnotationHandler { + + public EFragmentHandler(ProcessingEnvironment processingEnvironment) { + super(EFragment.class, processingEnvironment); + } + + @Override + public EFragmentHolder createGeneratedClassHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + return new EFragmentHolder(processHolder, annotatedElement); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.isNotFinal(element, valid); + + validatorHelper.resIdsExist(element, IRClass.Res.LAYOUT, IdValidatorHelper.FallbackStrategy.ALLOW_NO_RES_ID, valid); + + validatorHelper.isNotPrivate(element, valid); + + validatorHelper.hasEmptyConstructor(element, valid); + + validatorHelper.extendsFragment(element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EFragmentHolder holder) { + + IdAnnotationHelper idAnnotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); + + JFieldRef contentViewId = idAnnotationHelper.extractOneAnnotationFieldRef(holder, element, IRClass.Res.LAYOUT, false); + + if (contentViewId != null) { + + JBlock block = holder.getSetContentViewBlock(); + JVar inflater = holder.getInflater(); + JVar container = holder.getContainer(); + + JFieldVar contentView = holder.getContentView(); + + block._if(contentView.eq(_null())) // + ._then() // + .assign(contentView, inflater.invoke("inflate").arg(contentViewId).arg(container).arg(FALSE)); + } + + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/HoloEverywhereHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/HoloEverywhereHelper.java new file mode 100644 index 0000000000..1ed2c501cb --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/HoloEverywhereHelper.java @@ -0,0 +1,31 @@ +package org.androidannotations.helper; + +import org.androidannotations.holder.EComponentHolder; + +import javax.lang.model.element.TypeElement; +import javax.lang.model.type.DeclaredType; +import javax.lang.model.type.NoType; +import javax.lang.model.type.TypeMirror; + +public class HoloEverywhereHelper { + + private EComponentHolder holder; + + public HoloEverywhereHelper(EComponentHolder holder) { + this.holder = holder; + } + + public boolean usesHoloEverywhere() { + TypeElement typeElement = holder.getAnnotatedElement(); + + TypeMirror superType; + while (!((superType = typeElement.getSuperclass()) instanceof NoType)) { + typeElement = (TypeElement) ((DeclaredType) superType).asElement(); + String qName = typeElement.getQualifiedName().toString(); + if (qName.startsWith("org.holoeverywhere")) { + return true; + } + } + return false; + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdAnnotationHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdAnnotationHelper.java index af34c1606b..32d2fec85a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdAnnotationHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdAnnotationHelper.java @@ -15,17 +15,16 @@ */ package org.androidannotations.helper; -import java.util.List; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; - +import com.sun.codemodel.JFieldRef; +import org.androidannotations.holder.GeneratedClassHolder; import org.androidannotations.processing.EBeanHolder; import org.androidannotations.rclass.IRClass; import org.androidannotations.rclass.IRClass.Res; import org.androidannotations.rclass.IRInnerClass; -import com.sun.codemodel.JFieldRef; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import java.util.List; public class IdAnnotationHelper extends TargetAnnotationHelper { @@ -54,10 +53,24 @@ public List extractAnnotationFieldRefs(EBeanHolder holder, Element el return super.extractAnnotationFieldRefs(holder, element, getTarget(), rClass.get(res), useElementName); } + public JFieldRef extractOneAnnotationFieldRef(GeneratedClassHolder holder, Element element, Res res, boolean useElementName) { + return extractOneAnnotationFieldRef(holder, element, getTarget(), res, useElementName); + } + public JFieldRef extractOneAnnotationFieldRef(EBeanHolder holder, Element element, Res res, boolean useElementName) { return extractOneAnnotationFieldRef(holder, element, getTarget(), res, useElementName); } + public JFieldRef extractOneAnnotationFieldRef(GeneratedClassHolder holder, Element element, String annotationName, Res res, boolean useElementName) { + List jFieldRefs = extractAnnotationFieldRefs(holder, element, annotationName, rClass.get(res), useElementName); + + if (jFieldRefs.size() == 1) { + return jFieldRefs.get(0); + } else { + return null; + } + } + public JFieldRef extractOneAnnotationFieldRef(EBeanHolder holder, Element element, String annotationName, Res res, boolean useElementName) { List jFieldRefs = extractAnnotationFieldRefs(holder, element, annotationName, rClass.get(res), useElementName); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java new file mode 100644 index 0000000000..e8ed285f9a --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java @@ -0,0 +1,165 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.*; +import org.androidannotations.helper.HoloEverywhereHelper; +import org.androidannotations.helper.ViewNotifierHelper; +import org.androidannotations.process.ProcessHolder; + +import javax.lang.model.element.TypeElement; + +import static com.sun.codemodel.JExpr.*; +import static com.sun.codemodel.JMod.*; + +public class EFragmentHolder extends EComponentHolder { + + private ViewNotifierHelper viewNotifierHelper; + private JFieldVar contentView; + private JBlock setContentViewBlock; + private JVar inflater; + private JVar container; + private JDefinedClass fragmentBuilderClass; + private JFieldVar fragmentArgumentsBuilderField; + + public EFragmentHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + super(processHolder, annotatedElement); + viewNotifierHelper = new ViewNotifierHelper(this); + createOnCreate(); + createOnViewCreated(); + createFragmentBuilder(); + } + + private void createOnCreate() { + JMethod onCreate = generatedClass.method(PUBLIC, codeModel().VOID, "onCreate"); + onCreate.annotate(Override.class); + JVar onCreateSavedInstanceState = onCreate.param(classes().BUNDLE, "savedInstanceState"); + JBlock onCreateBody = onCreate.body(); + + JVar previousNotifier = viewNotifierHelper.replacePreviousNotifier(onCreateBody); + createFindViewById(); + onCreateBody.invoke(getInit()).arg(onCreateSavedInstanceState); + onCreateBody.invoke(_super(), onCreate).arg(onCreateSavedInstanceState); + viewNotifierHelper.resetPreviousNotifier(onCreateBody, previousNotifier); + } + + private void createOnViewCreated() { + JMethod onViewCreated = generatedClass.method(PUBLIC, codeModel().VOID, "onViewCreated"); + onViewCreated.annotate(Override.class); + JVar view = onViewCreated.param(classes().VIEW, "view"); + JVar savedInstanceState = onViewCreated.param(classes().BUNDLE, "savedInstanceState"); + JBlock onViewCreatedBody = onViewCreated.body(); + onViewCreatedBody.invoke(_super(), onViewCreated).arg(view).arg(savedInstanceState); + viewNotifierHelper.invokeViewChanged(onViewCreatedBody); + } + + private void createFindViewById() { + JMethod findViewById = generatedClass.method(PUBLIC, classes().VIEW, "findViewById"); + JVar idParam = findViewById.param(codeModel().INT, "id"); + + JBlock body = findViewById.body(); + + JFieldVar contentView = getContentView(); + + body._if(contentView.eq(_null())) // + ._then()._return(_null()); + + body._return(contentView.invoke(findViewById).arg(idParam)); + } + + private void createFragmentBuilder() throws JClassAlreadyExistsException { + fragmentBuilderClass = generatedClass._class(PUBLIC | STATIC, "FragmentBuilder_"); + fragmentArgumentsBuilderField = fragmentBuilderClass.field(PRIVATE, classes().BUNDLE, "args_"); + createFragmentBuilderConstructor(); + createFragmentBuilderBuild(); + createFragmentBuilderCreate(); + } + + private void createFragmentBuilderConstructor() { + JMethod constructor = fragmentBuilderClass.constructor(PRIVATE); + JBlock constructorBody = constructor.body(); + constructorBody.assign(fragmentArgumentsBuilderField, _new(classes().BUNDLE)); + } + + private void createFragmentBuilderBuild() { + JMethod method = fragmentBuilderClass.method(PUBLIC, generatedClass._extends(), "build"); + JBlock body = method.body(); + + JVar fragment = body.decl(generatedClass, "fragment_", _new(generatedClass)); + body.invoke(fragment, "setArguments").arg(fragmentArgumentsBuilderField); + body._return(fragment); + } + private void createFragmentBuilderCreate() { + JMethod method = generatedClass.method(STATIC | PUBLIC, fragmentBuilderClass, "builder"); + method.body()._return(_new(fragmentBuilderClass)); + } + + @Override + protected void setContextRef() { + contextRef = JExpr.invoke("getActivity"); + } + + @Override + protected void setInit() { + init = generatedClass.method(PRIVATE, codeModel().VOID, "init_"); + init.param(classes().BUNDLE, "savedInstanceState"); + } + + public JFieldVar getContentView() { + if (contentView == null) { + setContentView(); + setOnCreateView(); + } + return contentView; + } + + private void setContentView() { + contentView = generatedClass.field(PRIVATE, classes().VIEW, "contentView_"); + } + + private void setOnCreateView() { + JMethod onCreateView = generatedClass.method(PUBLIC, classes().VIEW, "onCreateView"); + onCreateView.annotate(Override.class); + + HoloEverywhereHelper holoEverywhereHelper = new HoloEverywhereHelper(this); + JClass inflaterClass; + if (holoEverywhereHelper.usesHoloEverywhere()) { + inflaterClass = classes().HOLO_EVERYWHERE_LAYOUT_INFLATER; + } else { + inflaterClass = classes().LAYOUT_INFLATER; + } + + inflater = onCreateView.param(inflaterClass, "inflater"); + container = onCreateView.param(classes().VIEW_GROUP, "container"); + + JVar savedInstanceState = onCreateView.param(classes().BUNDLE, "savedInstanceState"); + + JBlock body = onCreateView.body(); + body.assign(contentView, _super().invoke(onCreateView).arg(inflater).arg(container).arg(savedInstanceState)); + + setContentViewBlock = body.block(); + + body._return(contentView); + } + + public JBlock getSetContentViewBlock() { + if (setContentViewBlock == null) { + setOnCreateView(); + } + return setContentViewBlock; + } + + public JVar getInflater() { + if (inflater == null) { + setOnCreateView(); + } + return inflater; + } + + public JVar getContainer() { + if (container == null) { + setOnCreateView(); + } + return container; + } + + +} From b57cd254aa08d03e19e9d24c64417560c2238519 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 23 May 2013 14:54:39 +0200 Subject: [PATCH 06/86] Implement EProviderHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/EProviderHandler.java | 41 +++++++++++++++++++ .../holder/EProviderHolder.java | 38 +++++++++++++++++ 3 files changed, 80 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EProviderHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EProviderHolder.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 1d679d6022..1d51093637 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -20,6 +20,7 @@ public class AnnotationHandlers { public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new EApplicationHandler(processingEnvironment)); add(new EActivityHandler(processingEnvironment)); + add(new EProviderHandler(processingEnvironment)); add(new EFragmentHandler(processingEnvironment)); add(new EBeanHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EProviderHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EProviderHandler.java new file mode 100644 index 0000000000..8567f53fa3 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EProviderHandler.java @@ -0,0 +1,41 @@ +package org.androidannotations.handler; + +import org.androidannotations.annotations.EProvider; +import org.androidannotations.holder.EProviderHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.ProcessHolder; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; + +public class EProviderHandler extends BaseAnnotationHandler implements GeneratingAnnotationHandler { + + public EProviderHandler(ProcessingEnvironment processingEnvironment) { + super(EProvider.class, processingEnvironment); + } + + @Override + public EProviderHolder createGeneratedClassHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + return new EProviderHolder(processHolder, annotatedElement); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.extendsProvider(element, valid); + + validatorHelper.isNotFinal(element, valid); + + validatorHelper.componentRegistered(element, androidManifest, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EProviderHolder holder) { + /* Do nothing */ + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EProviderHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EProviderHolder.java new file mode 100644 index 0000000000..6fbf626bd3 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EProviderHolder.java @@ -0,0 +1,38 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JMethod; +import org.androidannotations.process.ProcessHolder; + +import javax.lang.model.element.TypeElement; + +import static com.sun.codemodel.JExpr._super; +import static com.sun.codemodel.JExpr.invoke; +import static com.sun.codemodel.JMod.PRIVATE; +import static com.sun.codemodel.JMod.PUBLIC; + +public class EProviderHolder extends EComponentHolder { + + public EProviderHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + super(processHolder, annotatedElement); + } + + @Override + protected void setContextRef() { + contextRef = invoke("getContext"); + } + + @Override + protected void setInit() { + init = generatedClass.method(PRIVATE, codeModel().VOID, "init_"); + createOnCreate(); + } + + private void createOnCreate() { + JMethod onCreate = generatedClass.method(PUBLIC, codeModel().BOOLEAN, "onCreate"); + onCreate.annotate(Override.class); + JBlock onCreateBody = onCreate.body(); + onCreateBody.invoke(getInit()); + onCreateBody._return(invoke(_super(), onCreate)); + } +} From 033807bf4ea55db84cd5ce272149bc08444c5b9a Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 23 May 2013 15:02:33 +0200 Subject: [PATCH 07/86] Implement EReceiverHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/EReceiverHandler.java | 42 ++++++++++++++++ .../holder/EReceiverHolder.java | 48 +++++++++++++++++++ 3 files changed, 91 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EReceiverHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EReceiverHolder.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 1d51093637..be06f5b685 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -21,6 +21,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new EApplicationHandler(processingEnvironment)); add(new EActivityHandler(processingEnvironment)); add(new EProviderHandler(processingEnvironment)); + add(new EReceiverHandler(processingEnvironment)); add(new EFragmentHandler(processingEnvironment)); add(new EBeanHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EReceiverHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EReceiverHandler.java new file mode 100644 index 0000000000..1b7e225932 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EReceiverHandler.java @@ -0,0 +1,42 @@ +package org.androidannotations.handler; + +import org.androidannotations.annotations.EReceiver; +import org.androidannotations.holder.EReceiverHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.ProcessHolder; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; + +public class EReceiverHandler extends BaseAnnotationHandler implements GeneratingAnnotationHandler { + + public EReceiverHandler(ProcessingEnvironment processingEnvironment) { + super(EReceiver.class, processingEnvironment); + } + + @Override + public EReceiverHolder createGeneratedClassHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + return new EReceiverHolder(processHolder, annotatedElement); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.extendsReceiver(element, valid); + + validatorHelper.isNotFinal(element, valid); + + final boolean NO_WARNING = false; + validatorHelper.componentRegistered(element, androidManifest, NO_WARNING, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EReceiverHolder holder) { + /* Do nothing */ + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EReceiverHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EReceiverHolder.java new file mode 100644 index 0000000000..262b768428 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EReceiverHolder.java @@ -0,0 +1,48 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.*; +import org.androidannotations.process.ProcessHolder; + +import javax.lang.model.element.TypeElement; + +import static com.sun.codemodel.JMod.PRIVATE; +import static com.sun.codemodel.JMod.PUBLIC; + +public class EReceiverHolder extends EComponentHolder { + + private JFieldVar contextField; + + public EReceiverHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + super(processHolder, annotatedElement); + } + + @Override + protected void setContextRef() { + contextField = generatedClass.field(PRIVATE, classes().CONTEXT, "context_"); + contextRef = contextField; + } + + @Override + protected void setInit() { + init = generatedClass.method(PRIVATE, codeModel().VOID, "init_"); + createOnReceive(); + } + + private void createOnReceive() { + JMethod onReceive = generatedClass.method(PUBLIC, codeModel().VOID, "onReceive"); + JVar contextParam = onReceive.param(classes().CONTEXT, "context"); + JVar intentParam = onReceive.param(classes().INTENT, "intent"); + onReceive.annotate(Override.class); + JBlock onReceiveBody = onReceive.body(); + onReceiveBody.assign(getContextField(), contextParam); + onReceiveBody.invoke(getInit()); + onReceiveBody.invoke(JExpr._super(), onReceive).arg(contextParam).arg(intentParam); + } + + public JFieldVar getContextField() { + if (contextField == null) { + setContextRef(); + } + return contextField; + } +} From 02d42a63697c8ef6add115ad0abdddf52b535dea Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 23 May 2013 15:09:33 +0200 Subject: [PATCH 08/86] Implement EServiceHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/EServiceHandler.java | 41 ++++++++++++ .../holder/EServiceHolder.java | 65 +++++++++++++++++++ 3 files changed, 107 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EServiceHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EServiceHolder.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index be06f5b685..9553cbc435 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -22,6 +22,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new EActivityHandler(processingEnvironment)); add(new EProviderHandler(processingEnvironment)); add(new EReceiverHandler(processingEnvironment)); + add(new EServiceHandler(processingEnvironment)); add(new EFragmentHandler(processingEnvironment)); add(new EBeanHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EServiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EServiceHandler.java new file mode 100644 index 0000000000..5212db814d --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EServiceHandler.java @@ -0,0 +1,41 @@ +package org.androidannotations.handler; + +import org.androidannotations.annotations.EService; +import org.androidannotations.holder.EServiceHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.ProcessHolder; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; + +public class EServiceHandler extends BaseAnnotationHandler implements GeneratingAnnotationHandler { + + public EServiceHandler(ProcessingEnvironment processingEnvironment) { + super(EService.class, processingEnvironment); + } + + @Override + public EServiceHolder createGeneratedClassHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + return new EServiceHolder(processHolder, annotatedElement); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.extendsService(element, valid); + + validatorHelper.isNotFinal(element, valid); + + validatorHelper.componentRegistered(element, androidManifest, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EServiceHolder holder) { + /* Do nothing */ + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EServiceHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EServiceHolder.java new file mode 100644 index 0000000000..ae1d1a1efc --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EServiceHolder.java @@ -0,0 +1,65 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.*; +import org.androidannotations.helper.ServiceIntentBuilder; +import org.androidannotations.process.ProcessHolder; + +import javax.lang.model.element.TypeElement; + +import static com.sun.codemodel.JExpr._this; +import static com.sun.codemodel.JMod.PRIVATE; +import static com.sun.codemodel.JMod.PUBLIC; + +public class EServiceHolder extends EComponentHolder implements HasIntentBuilder { + + private JDefinedClass intentBuilderClass; + private JFieldVar intentField; + + public EServiceHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + super(processHolder, annotatedElement); + createIntentBuilder(); + } + + private void createIntentBuilder() throws JClassAlreadyExistsException { + new ServiceIntentBuilder(this).build(); + } + + @Override + protected void setContextRef() { + contextRef = _this(); + } + + @Override + protected void setInit() { + init = generatedClass.method(PRIVATE, codeModel().VOID, "init_"); + createOnCreate(); + } + + private void createOnCreate() { + JMethod onCreate = generatedClass.method(PUBLIC, codeModel().VOID, "onCreate"); + onCreate.annotate(Override.class); + JBlock onCreateBody = onCreate.body(); + onCreateBody.invoke(getInit()); + onCreateBody.invoke(JExpr._super(), onCreate); + } + + @Override + public void setIntentBuilderClass(JDefinedClass intentBuilderClass) { + this.intentBuilderClass = intentBuilderClass; + } + + @Override + public JDefinedClass getIntentBuilderClass() { + return intentBuilderClass; + } + + @Override + public void setIntentField(JFieldVar intentField) { + this.intentField = intentField; + } + + @Override + public JFieldVar getIntentField() { + return intentField; + } +} From a7f29930a896513770ab71688a6ed4e94641d94b Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 23 May 2013 15:56:26 +0200 Subject: [PATCH 09/86] Implement EViewHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/EViewHandler.java | 39 +++++ .../holder/EViewHolder.java | 137 ++++++++++++++++++ 3 files changed, 177 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 9553cbc435..5030a7d913 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -25,6 +25,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new EServiceHandler(processingEnvironment)); add(new EFragmentHandler(processingEnvironment)); add(new EBeanHandler(processingEnvironment)); + add(new EViewHandler(processingEnvironment)); } private void add(AnnotationHandler annotationHandler) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewHandler.java new file mode 100644 index 0000000000..98073e5f77 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewHandler.java @@ -0,0 +1,39 @@ +package org.androidannotations.handler; + +import org.androidannotations.annotations.EView; +import org.androidannotations.holder.EViewHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.ProcessHolder; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; + +public class EViewHandler extends BaseAnnotationHandler implements GeneratingAnnotationHandler { + + public EViewHandler(ProcessingEnvironment processingEnvironment) { + super(EView.class, processingEnvironment); + } + + @Override + public EViewHolder createGeneratedClassHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + return new EViewHolder(processHolder, annotatedElement); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.extendsView(element, valid); + + validatorHelper.isNotFinal(element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EViewHolder holder) { + /* Do nothing */ + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java new file mode 100644 index 0000000000..f9e5e13035 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java @@ -0,0 +1,137 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.*; +import org.androidannotations.helper.ModelConstants; +import org.androidannotations.helper.ViewNotifierHelper; +import org.androidannotations.process.ProcessHolder; + +import javax.lang.model.element.*; +import java.util.ArrayList; +import java.util.List; + +import static com.sun.codemodel.JExpr.invoke; +import static com.sun.codemodel.JMod.*; +import static javax.lang.model.element.ElementKind.CONSTRUCTOR; + +public class EViewHolder extends EComponentHolder { + + private static final String ALREADY_INFLATED_COMMENT = "" // + + + "The mAlreadyInflated_ hack is needed because of an Android bug\n" // + + + "which leads to infinite calls of onFinishInflate()\n" // + + "when inflating a layout with a parent and using\n" // + + "the tag." // + ; + + private static final String SUPPRESS_WARNING_COMMENT = "" // + + "We use @SuppressWarning here because our java code\n" // + + "generator doesn't know that there is no need\n" // + + "to import OnXXXListeners from View as we already\n" // + + "are in a View." // + ; + + private ViewNotifierHelper viewNotifierHelper; + private JMethod onFinishInflate; + private JFieldVar alreadyInflated; + + public EViewHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + super(processHolder, annotatedElement); + viewNotifierHelper = new ViewNotifierHelper(this); + addSuppressWarning(); + createConstructorAndBuilder(); + } + + @Override + protected void setGeneratedClass() throws Exception { + String annotatedComponentQualifiedName = annotatedElement.getQualifiedName().toString(); + String generatedBeanQualifiedName = annotatedComponentQualifiedName + ModelConstants.GENERATION_SUFFIX; + JClass annotatedComponent = codeModel().directClass(annotatedComponentQualifiedName); + + int modifiers; + if (annotatedElement.getModifiers().contains(Modifier.ABSTRACT)) { + modifiers = JMod.PUBLIC | JMod.ABSTRACT; + } else { + modifiers = JMod.PUBLIC | JMod.FINAL; + } + + generatedClass = codeModel()._class(modifiers, generatedBeanQualifiedName, ClassType.CLASS); + generatedClass._extends(annotatedComponent); + } + + private void addSuppressWarning() { + generatedClass.annotate(SuppressWarnings.class).param("value", "unused"); + generatedClass.javadoc().append(SUPPRESS_WARNING_COMMENT); + } + + private void createConstructorAndBuilder() { + List constructors = new ArrayList(); + for (Element e : annotatedElement.getEnclosedElements()) { + if (e.getKind() == CONSTRUCTOR) { + constructors.add((ExecutableElement) e); + } + } + + for (ExecutableElement userConstructor : constructors) { + JMethod copyConstructor = generatedClass.constructor(PUBLIC); + JMethod staticHelper = generatedClass.method(PUBLIC | STATIC, generatedClass._extends(), "build"); + JBlock body = copyConstructor.body(); + JInvocation superCall = body.invoke("super"); + JInvocation newInvocation = JExpr._new(generatedClass); + for (VariableElement param : userConstructor.getParameters()) { + String paramName = param.getSimpleName().toString(); + String paramType = param.asType().toString(); + copyConstructor.param(refClass(paramType), paramName); + staticHelper.param(refClass(paramType), paramName); + superCall.arg(JExpr.ref(paramName)); + newInvocation.arg(JExpr.ref(paramName)); + } + + JVar newCall = staticHelper.body().decl(generatedClass, "instance", newInvocation); + staticHelper.body().invoke(newCall, getOnFinishInflate()); + staticHelper.body()._return(newCall); + body.invoke(getInit()); + } + } + + @Override + protected void setContextRef() { + contextRef = invoke("getContext"); + } + + @Override + protected void setInit() { + init = generatedClass.method(PRIVATE, codeModel().VOID, "init_"); + viewNotifierHelper.wrapInitWithNotifier(); + } + + public JMethod getOnFinishInflate() { + if (onFinishInflate == null) { + setOnFinishInflate(); + } + return onFinishInflate; + } + + private void setOnFinishInflate() { + onFinishInflate = generatedClass.method(PUBLIC, codeModel().VOID, "onFinishInflate"); + onFinishInflate.annotate(Override.class); + onFinishInflate.javadoc().append(ALREADY_INFLATED_COMMENT); + + JBlock ifNotInflated = onFinishInflate.body()._if(getAlreadyInflated().not())._then(); + ifNotInflated.assign(getAlreadyInflated(), JExpr.TRUE); + + getInit(); + viewNotifierHelper.invokeViewChanged(ifNotInflated); + + onFinishInflate.body().invoke(JExpr._super(), "onFinishInflate"); + } + + public JFieldVar getAlreadyInflated() { + if (alreadyInflated == null) { + setAlreadyInflated(); + } + return alreadyInflated; + } + + private void setAlreadyInflated() { + alreadyInflated = generatedClass.field(PRIVATE, JType.parse(codeModel(), "boolean"), "alreadyInflated_", JExpr.FALSE); + } +} From 4caf816939ff152c49be16d76f66a2316295ec27 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 23 May 2013 16:34:39 +0200 Subject: [PATCH 10/86] Implement EViewGroupHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/EViewGroupHandler.java | 59 +++++++++++++++++++ .../holder/EViewGroupHolder.java | 41 +++++++++++++ .../holder/EViewHolder.java | 10 ++-- 4 files changed, 106 insertions(+), 5 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewGroupHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewGroupHolder.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 5030a7d913..7b88c105e9 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -25,6 +25,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new EServiceHandler(processingEnvironment)); add(new EFragmentHandler(processingEnvironment)); add(new EBeanHandler(processingEnvironment)); + add(new EViewGroupHandler(processingEnvironment)); add(new EViewHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewGroupHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewGroupHandler.java new file mode 100644 index 0000000000..2b36188b9f --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewGroupHandler.java @@ -0,0 +1,59 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JFieldRef; +import org.androidannotations.annotations.EViewGroup; +import org.androidannotations.helper.AndroidManifest; +import org.androidannotations.helper.IdAnnotationHelper; +import org.androidannotations.helper.IdValidatorHelper; +import org.androidannotations.holder.EViewGroupHolder; +import org.androidannotations.model.AndroidSystemServices; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.ProcessHolder; +import org.androidannotations.rclass.IRClass; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; + +public class EViewGroupHandler extends BaseAnnotationHandler implements GeneratingAnnotationHandler { + + private IdAnnotationHelper annotationHelper; + + public EViewGroupHandler(ProcessingEnvironment processingEnvironment) { + super(EViewGroup.class, processingEnvironment); + } + + @Override + public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) { + super.setAndroidEnvironment(rClass, androidSystemServices, androidManifest); + annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); + } + + @Override + public EViewGroupHolder createGeneratedClassHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + return new EViewGroupHolder(processHolder, annotatedElement); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.extendsViewGroup(element, valid); + + validatorHelper.resIdsExist(element, IRClass.Res.LAYOUT, IdValidatorHelper.FallbackStrategy.ALLOW_NO_RES_ID, valid); + + validatorHelper.isNotFinal(element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EViewGroupHolder holder) { + JFieldRef contentViewId = annotationHelper.extractOneAnnotationFieldRef(holder, element, IRClass.Res.LAYOUT, false); + if (contentViewId != null) { + holder.getSetContentViewBlock().invoke("inflate").arg(holder.getContextRef()).arg(contentViewId).arg(JExpr._this()); + } + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewGroupHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewGroupHolder.java new file mode 100644 index 0000000000..2a85322fc8 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewGroupHolder.java @@ -0,0 +1,41 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JExpr; +import org.androidannotations.process.ProcessHolder; + +import javax.lang.model.element.TypeElement; + +import static com.sun.codemodel.JMod.PUBLIC; + +public class EViewGroupHolder extends EViewHolder { + + private JBlock setContentViewBlock; + + public EViewGroupHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + super(processHolder, annotatedElement); + } + + protected void setOnFinishInflate() { + onFinishInflate = generatedClass.method(PUBLIC, codeModel().VOID, "onFinishInflate"); + onFinishInflate.annotate(Override.class); + onFinishInflate.javadoc().append(ALREADY_INFLATED_COMMENT); + + JBlock ifNotInflated = onFinishInflate.body()._if(getAlreadyInflated().not())._then(); + ifNotInflated.assign(getAlreadyInflated(), JExpr.TRUE); + + setContentViewBlock = ifNotInflated.block(); + + getInit(); + viewNotifierHelper.invokeViewChanged(ifNotInflated); + + onFinishInflate.body().invoke(JExpr._super(), "onFinishInflate"); + } + + public JBlock getSetContentViewBlock() { + if (setContentViewBlock == null) { + setOnFinishInflate(); + } + return setContentViewBlock; + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java index f9e5e13035..d97dfc376a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java @@ -15,7 +15,7 @@ public class EViewHolder extends EComponentHolder { - private static final String ALREADY_INFLATED_COMMENT = "" // + + protected static final String ALREADY_INFLATED_COMMENT = "" // + + "The mAlreadyInflated_ hack is needed because of an Android bug\n" // + + "which leads to infinite calls of onFinishInflate()\n" // + "when inflating a layout with a parent and using\n" // @@ -29,9 +29,9 @@ public class EViewHolder extends EComponentHolder { + "are in a View." // ; - private ViewNotifierHelper viewNotifierHelper; - private JMethod onFinishInflate; - private JFieldVar alreadyInflated; + protected ViewNotifierHelper viewNotifierHelper; + protected JMethod onFinishInflate; + protected JFieldVar alreadyInflated; public EViewHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); @@ -110,7 +110,7 @@ public JMethod getOnFinishInflate() { return onFinishInflate; } - private void setOnFinishInflate() { + protected void setOnFinishInflate() { onFinishInflate = generatedClass.method(PUBLIC, codeModel().VOID, "onFinishInflate"); onFinishInflate.annotate(Override.class); onFinishInflate.javadoc().append(ALREADY_INFLATED_COMMENT); From b685ed469ca9864a8f06c563bb686750377e33f9 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 23 May 2013 17:01:43 +0200 Subject: [PATCH 11/86] Implement AfterInjectHandler --- .../handler/AfterInjectHandler.java | 42 +++++++++++++++++++ .../handler/AnnotationHandlers.java | 1 + 2 files changed, 43 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterInjectHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterInjectHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterInjectHandler.java new file mode 100644 index 0000000000..d12c5f997b --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterInjectHandler.java @@ -0,0 +1,42 @@ +package org.androidannotations.handler; + +import org.androidannotations.annotations.AfterInject; +import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; + +public class AfterInjectHandler extends BaseAnnotationHandler { + + public AfterInjectHandler(ProcessingEnvironment processingEnvironment) { + super(AfterInject.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); + + ExecutableElement executableElement = (ExecutableElement) element; + + validatorHelper.returnTypeIsVoid(executableElement, valid); + + validatorHelper.isNotPrivate(element, valid); + + validatorHelper.doesntThrowException(executableElement, valid); + + validatorHelper.param.zeroParameter(executableElement, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EComponentHolder holder) { + String methodName = element.getSimpleName().toString(); + holder.getInit().body().invoke(methodName); + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 7b88c105e9..7967f0a3ca 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -27,6 +27,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new EBeanHandler(processingEnvironment)); add(new EViewGroupHandler(processingEnvironment)); add(new EViewHandler(processingEnvironment)); + add(new AfterInjectHandler(processingEnvironment)); } private void add(AnnotationHandler annotationHandler) { From b7fa4773b5952d8fa7966129d97b152c916601d5 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 23 May 2013 19:20:00 +0200 Subject: [PATCH 12/86] Implement SharedPrefHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/SharedPrefHandler.java | 251 ++++++++++++++++++ .../helper/ValidatorHelper.java | 89 ++----- .../holder/SharedPrefHolder.java | 126 +++++++++ .../validation/SharedPrefValidator.java | 19 +- 5 files changed, 412 insertions(+), 74 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SharedPrefHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/SharedPrefHolder.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 7967f0a3ca..002ee692e4 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -27,6 +27,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new EBeanHandler(processingEnvironment)); add(new EViewGroupHandler(processingEnvironment)); add(new EViewHandler(processingEnvironment)); + add(new SharedPrefHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SharedPrefHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SharedPrefHandler.java new file mode 100644 index 0000000000..3747877eb2 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SharedPrefHandler.java @@ -0,0 +1,251 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.sharedpreferences.*; +import org.androidannotations.api.sharedpreferences.*; +import org.androidannotations.helper.AndroidManifest; +import org.androidannotations.helper.CanonicalNameConstants; +import org.androidannotations.helper.IdAnnotationHelper; +import org.androidannotations.holder.SharedPrefHolder; +import org.androidannotations.model.AndroidSystemServices; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.ProcessHolder; +import org.androidannotations.rclass.IRClass; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.TypeElement; +import javax.lang.model.util.ElementFilter; +import java.util.ArrayList; +import java.util.List; + +import static com.sun.codemodel.JExpr.invoke; +import static com.sun.codemodel.JExpr.lit; +import static com.sun.codemodel.JMod.PRIVATE; +import static com.sun.codemodel.JMod.STATIC; + +public class SharedPrefHandler extends BaseAnnotationHandler implements GeneratingAnnotationHandler { + + private IdAnnotationHelper annotationHelper; + + public SharedPrefHandler(ProcessingEnvironment processingEnvironment) { + super(SharedPref.class, processingEnvironment); + } + + @Override + public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) { + super.setAndroidEnvironment(rClass, androidSystemServices, androidManifest); + annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); + } + + @Override + public SharedPrefHolder createGeneratedClassHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + return new SharedPrefHolder(processHolder, annotatedElement); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + TypeElement typeElement = (TypeElement) element; + + validatorHelper.isInterface(typeElement, valid); + + List inheritedMembers = processingEnv.getElementUtils().getAllMembers(typeElement); + + for (Element memberElement : inheritedMembers) { + if (!memberElement.getEnclosingElement().asType().toString().equals("java.lang.Object")) { + validatorHelper.isPrefMethod(memberElement, valid); + if (valid.isValid()) { + validatorHelper.hasCorrectDefaultAnnotation((ExecutableElement) memberElement, valid); + } + } + } + + return valid.isValid(); + } + + @Override + public void process(Element element, SharedPrefHolder holder) { + generateApiClasses(element, holder); + generateConstructor(element, holder); + generateFieldMethodAndEditorFieldMethod(element, holder); + } + + private void generateApiClasses(Element originatingElement, SharedPrefHolder holder) { + holder.generateApiClass(originatingElement, AbstractPrefEditorField.class); + holder.generateApiClass(originatingElement, AbstractPrefField.class); + holder.generateApiClass(originatingElement, BooleanPrefEditorField.class); + holder.generateApiClass(originatingElement, BooleanPrefField.class); + holder.generateApiClass(originatingElement, EditorHelper.class); + holder.generateApiClass(originatingElement, FloatPrefEditorField.class); + holder.generateApiClass(originatingElement, FloatPrefField.class); + holder.generateApiClass(originatingElement, IntPrefEditorField.class); + holder.generateApiClass(originatingElement, IntPrefField.class); + holder.generateApiClass(originatingElement, LongPrefEditorField.class); + holder.generateApiClass(originatingElement, LongPrefField.class); + holder.generateApiClass(originatingElement, SharedPreferencesCompat.class); + holder.generateApiClass(originatingElement, SharedPreferencesHelper.class); + holder.generateApiClass(originatingElement, StringPrefEditorField.class); + holder.generateApiClass(originatingElement, StringPrefField.class); + } + + private void generateConstructor(Element element, SharedPrefHolder holder) { + SharedPref sharedPrefAnnotation = element.getAnnotation(SharedPref.class); + SharedPref.Scope scope = sharedPrefAnnotation.value(); + int mode = sharedPrefAnnotation.mode(); + + String interfaceSimpleName = element.getSimpleName().toString(); + JBlock constructorSuperBlock = holder.getConstructorSuperBlock(); + JVar contextParam = holder.getConstructorContextParam(); + + switch (scope) { + case ACTIVITY_DEFAULT: { + JMethod getLocalClassName = getLocalClassName(holder); + constructorSuperBlock.invoke("super") // + .arg(contextParam.invoke("getSharedPreferences") // + .arg(invoke(getLocalClassName).arg(contextParam)) // + .arg(JExpr.lit(mode))); + break; + } + case ACTIVITY: { + JMethod getLocalClassName = getLocalClassName(holder); + constructorSuperBlock.invoke("super") // + .arg(contextParam.invoke("getSharedPreferences") // + .arg(invoke(getLocalClassName).arg(contextParam) // + .plus(JExpr.lit("_" + interfaceSimpleName))) // + .arg(JExpr.lit(mode))); + break; + } + case UNIQUE: { + constructorSuperBlock.invoke("super") // + .arg(contextParam.invoke("getSharedPreferences") // + .arg(JExpr.lit(interfaceSimpleName)) // + .arg(JExpr.lit(mode))); + break; + } + case APPLICATION_DEFAULT: { + JClass preferenceManagerClass = holder.refClass("android.preference.PreferenceManager"); + constructorSuperBlock.invoke("super") // + .arg(preferenceManagerClass.staticInvoke("getDefaultSharedPreferences") // + .arg(contextParam)); + break; + } + } + } + + private JMethod getLocalClassName(SharedPrefHolder holder) { + + JClass stringClass = holder.classes().STRING; + JMethod getLocalClassName = holder.getGeneratedClass().method(PRIVATE | STATIC, stringClass, "getLocalClassName"); + JClass contextClass = holder.classes().CONTEXT; + + JVar contextParam = getLocalClassName.param(contextClass, "context"); + + JBlock body = getLocalClassName.body(); + + JVar packageName = body.decl(stringClass, "packageName", contextParam.invoke("getPackageName")); + + JVar className = body.decl(stringClass, "className", contextParam.invoke("getClass").invoke("getName")); + + JVar packageLen = body.decl(holder.codeModel().INT, "packageLen", packageName.invoke("length")); + + JExpression condition = className.invoke("startsWith").arg(packageName).not() // + .cor(className.invoke("length").lte(packageLen)) // + .cor(className.invoke("charAt").arg(packageLen).ne(lit('.'))); + + body._if(condition)._then()._return(className); + + body._return(className.invoke("substring").arg(packageLen.plus(lit(1)))); + + return getLocalClassName; + } + + private void generateFieldMethodAndEditorFieldMethod(Element element, SharedPrefHolder sharedPrefHolder) { + for(ExecutableElement method : getValidMethods(element)) { + generateFieldMethod(sharedPrefHolder, method); + sharedPrefHolder.createEditorFieldMethods(method); + } + } + + private List getValidMethods(Element element) { + List members = element.getEnclosedElements(); + List methods = ElementFilter.methodsIn(members); + List validMethods = new ArrayList(); + for (ExecutableElement method : methods) { + validMethods.add(method); + } + return validMethods; + } + + private void generateFieldMethod(SharedPrefHolder holder, ExecutableElement method) { + String returnType = method.getReturnType().toString(); + JExpression defaultValue = null; + if ("boolean".equals(returnType)) { + DefaultBoolean defaultAnnotation = method.getAnnotation(DefaultBoolean.class); + if (defaultAnnotation != null) { + defaultValue = JExpr.lit(defaultAnnotation.value()); + } + createFieldMethod(holder, method, defaultValue, IRClass.Res.BOOL, JExpr.lit(false), BooleanPrefField.class, "booleanField"); + } else if ("float".equals(returnType)) { + DefaultFloat defaultAnnotation = method.getAnnotation(DefaultFloat.class); + if (defaultAnnotation != null) { + defaultValue = JExpr.lit(defaultAnnotation.value()); + } + createFieldMethod(holder, method, defaultValue, IRClass.Res.INTEGER, JExpr.lit(0f), FloatPrefField.class, "floatField"); + } else if ("int".equals(returnType)) { + DefaultInt defaultAnnotation = method.getAnnotation(DefaultInt.class); + if (defaultAnnotation != null) { + defaultValue = JExpr.lit(defaultAnnotation.value()); + } + createFieldMethod(holder, method, defaultValue, IRClass.Res.INTEGER, JExpr.lit(0), IntPrefField.class, "intField"); + } else if ("long".equals(returnType)) { + DefaultLong defaultAnnotation = method.getAnnotation(DefaultLong.class); + if (defaultAnnotation != null) { + defaultValue = JExpr.lit(defaultAnnotation.value()); + } + createFieldMethod(holder, method, defaultValue, IRClass.Res.INTEGER, JExpr.lit(0l), LongPrefField.class, "longField"); + } else if (CanonicalNameConstants.STRING.equals(returnType)) { + DefaultString defaultAnnotation = method.getAnnotation(DefaultString.class); + if (defaultAnnotation != null) { + defaultValue = JExpr.lit(defaultAnnotation.value()); + } + createFieldMethod(holder, method, defaultValue, IRClass.Res.STRING, JExpr.lit(""), StringPrefField.class, "stringField"); + } + } + + private void createFieldMethod(SharedPrefHolder holder, ExecutableElement method, JExpression defaultAnnotationValue, IRClass.Res res, JExpression defValue, Class booleanPrefFieldClass, String fieldHelperMethodName) { + JExpression defaultValue = defaultAnnotationValue; + if (defaultAnnotationValue == null) { + if (method.getAnnotation(DefaultRes.class) != null) { + defaultValue = extractResValue(holder, method,res); + } else { + defaultValue = defValue; + } + } + String fieldName = method.getSimpleName().toString(); + holder.createFieldMethod(booleanPrefFieldClass, fieldName, fieldHelperMethodName, defaultValue); + } + + private JExpression extractResValue(SharedPrefHolder holder, Element method, IRClass.Res res) { + JFieldRef idRef = annotationHelper.extractOneAnnotationFieldRef(holder, method, DefaultRes.class.getCanonicalName(), res, true); + + String resourceGetMethodName = null; + switch (res) { + case BOOL: + resourceGetMethodName = "getBoolean"; + break; + case INTEGER: + resourceGetMethodName = "getInteger"; + break; + case STRING: + resourceGetMethodName = "getString"; + break; + default: + break; + } + return holder.getContextField().invoke("getResources").invoke(resourceGetMethodName).arg(idRef); + } +} 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 f9b372f963..bd4378d9df 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java @@ -15,65 +15,27 @@ */ package org.androidannotations.helper; -import static java.util.Arrays.asList; -import static org.androidannotations.helper.AndroidConstants.LOG_DEBUG; -import static org.androidannotations.helper.AndroidConstants.LOG_ERROR; -import static org.androidannotations.helper.AndroidConstants.LOG_INFO; -import static org.androidannotations.helper.AndroidConstants.LOG_VERBOSE; -import static org.androidannotations.helper.AndroidConstants.LOG_WARN; -import static org.androidannotations.helper.CanonicalNameConstants.CLIENT_HTTP_REQUEST_INTERCEPTOR; -import static org.androidannotations.helper.CanonicalNameConstants.HTTP_MESSAGE_CONVERTER; -import static org.androidannotations.helper.CanonicalNameConstants.INTERNET_PERMISSION; -import static org.androidannotations.helper.ModelConstants.GENERATION_SUFFIX; -import static org.androidannotations.helper.ModelConstants.VALID_ENHANCED_COMPONENT_ANNOTATIONS; -import static org.androidannotations.helper.ModelConstants.VALID_ENHANCED_VIEW_SUPPORT_ANNOTATIONS; - -import java.lang.annotation.Annotation; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.List; -import java.util.Set; - -import javax.lang.model.element.AnnotationMirror; -import javax.lang.model.element.Element; -import javax.lang.model.element.ElementKind; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.Modifier; -import javax.lang.model.element.TypeElement; -import javax.lang.model.element.VariableElement; -import javax.lang.model.type.ArrayType; -import javax.lang.model.type.DeclaredType; -import javax.lang.model.type.ErrorType; -import javax.lang.model.type.TypeKind; -import javax.lang.model.type.TypeMirror; -import javax.lang.model.util.ElementFilter; -import javax.lang.model.util.Elements; - -import org.androidannotations.annotations.EActivity; -import org.androidannotations.annotations.EBean; -import org.androidannotations.annotations.EFragment; -import org.androidannotations.annotations.Trace; -import org.androidannotations.annotations.ViewById; -import org.androidannotations.annotations.rest.Delete; -import org.androidannotations.annotations.rest.Get; -import org.androidannotations.annotations.rest.Head; -import org.androidannotations.annotations.rest.Options; -import org.androidannotations.annotations.rest.Post; -import org.androidannotations.annotations.rest.Put; -import org.androidannotations.annotations.rest.Rest; -import org.androidannotations.annotations.sharedpreferences.DefaultBoolean; -import org.androidannotations.annotations.sharedpreferences.DefaultFloat; -import org.androidannotations.annotations.sharedpreferences.DefaultInt; -import org.androidannotations.annotations.sharedpreferences.DefaultLong; -import org.androidannotations.annotations.sharedpreferences.DefaultString; -import org.androidannotations.annotations.sharedpreferences.SharedPref; +import org.androidannotations.annotations.*; +import org.androidannotations.annotations.rest.*; +import org.androidannotations.annotations.sharedpreferences.*; import org.androidannotations.api.sharedpreferences.SharedPreferencesHelper; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; import org.androidannotations.processing.InstanceStateProcessor; import org.androidannotations.validation.IsValid; +import javax.lang.model.element.*; +import javax.lang.model.type.*; +import javax.lang.model.util.ElementFilter; +import javax.lang.model.util.Elements; +import java.lang.annotation.Annotation; +import java.util.*; + +import static java.util.Arrays.asList; +import static org.androidannotations.helper.AndroidConstants.*; +import static org.androidannotations.helper.CanonicalNameConstants.*; +import static org.androidannotations.helper.ModelConstants.*; + public class ValidatorHelper { private static final List ANDROID_FRAGMENT_QUALIFIED_NAMES = asList(CanonicalNameConstants.FRAGMENT, CanonicalNameConstants.SUPPORT_V4_FRAGMENT); @@ -708,7 +670,7 @@ public void isDeclaredType(Element element, IsValid valid, TypeMirror uiFieldTyp } } - public boolean isPrefMethod(Element element) { + public void isPrefMethod(Element element, IsValid valid) { if (!element.getKind().equals(ElementKind.METHOD)) { annotationHelper.printError(element, "Only methods are allowed in an " + annotationHelper.annotationName() + " annotated interface"); } else { @@ -725,25 +687,25 @@ public boolean isPrefMethod(Element element) { if (INVALID_PREF_METHOD_NAMES.contains(methodName)) { annotationHelper.printError(element, "The method name " + methodName + " is forbidden in an " + annotationHelper.annotationName() + " annotated interface"); } else { - return true; + return; } } } } - return false; + valid.invalidate(); } - public void hasCorrectDefaultAnnotation(ExecutableElement method) { - checkDefaultAnnotation(method, DefaultBoolean.class, "boolean", new TypeKindAnnotationCondition(TypeKind.BOOLEAN)); - checkDefaultAnnotation(method, DefaultFloat.class, "float", new TypeKindAnnotationCondition(TypeKind.FLOAT)); - checkDefaultAnnotation(method, DefaultInt.class, "int", new TypeKindAnnotationCondition(TypeKind.INT)); - checkDefaultAnnotation(method, DefaultLong.class, "long", new TypeKindAnnotationCondition(TypeKind.LONG)); + public void hasCorrectDefaultAnnotation(ExecutableElement method, IsValid valid) { + checkDefaultAnnotation(method, DefaultBoolean.class, "boolean", new TypeKindAnnotationCondition(TypeKind.BOOLEAN), valid); + checkDefaultAnnotation(method, DefaultFloat.class, "float", new TypeKindAnnotationCondition(TypeKind.FLOAT), valid); + checkDefaultAnnotation(method, DefaultInt.class, "int", new TypeKindAnnotationCondition(TypeKind.INT), valid); + checkDefaultAnnotation(method, DefaultLong.class, "long", new TypeKindAnnotationCondition(TypeKind.LONG), valid); checkDefaultAnnotation(method, DefaultString.class, "String", new DefaultAnnotationCondition() { @Override public boolean correctReturnType(TypeMirror returnType) { return returnType.toString().equals(CanonicalNameConstants.STRING); } - }); + }, valid); } private interface DefaultAnnotationCondition { @@ -765,11 +727,12 @@ public boolean correctReturnType(TypeMirror returnType) { } - private void checkDefaultAnnotation(ExecutableElement method, Class annotationClass, String expectedReturnType, DefaultAnnotationCondition condition) { + private void checkDefaultAnnotation(ExecutableElement method, Class annotationClass, String expectedReturnType, DefaultAnnotationCondition condition, IsValid valid) { T defaultAnnotation = method.getAnnotation(annotationClass); if (defaultAnnotation != null) { if (!condition.correctReturnType(method.getReturnType())) { annotationHelper.printAnnotationError(method, annotationClass.getName(), TargetAnnotationHelper.annotationName(annotationClass) + " can only be used on a method that returns a " + expectedReturnType); + valid.invalidate(); } } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/SharedPrefHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/SharedPrefHolder.java new file mode 100644 index 0000000000..de645a44b6 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/SharedPrefHolder.java @@ -0,0 +1,126 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.*; +import org.androidannotations.api.sharedpreferences.*; +import org.androidannotations.helper.CanonicalNameConstants; +import org.androidannotations.helper.ModelConstants; +import org.androidannotations.process.ProcessHolder; + +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.TypeElement; +import java.util.HashMap; +import java.util.Map; + +import static com.sun.codemodel.JMod.FINAL; +import static com.sun.codemodel.JMod.PUBLIC; + +public class SharedPrefHolder extends BaseGeneratedClassHolder { + + private static class EditorFieldHolder { + public final Class fieldClass; + public final String fieldMethodName; + + public EditorFieldHolder(Class fieldClass, String fieldMethodName) { + this.fieldClass = fieldClass; + this.fieldMethodName = fieldMethodName; + } + } + + private static final Map EDITOR_FIELD_BY_TYPE = new HashMap() { + private static final long serialVersionUID = 1L; + { + put("boolean", new EditorFieldHolder(BooleanPrefEditorField.class, "booleanField")); + put("float", new EditorFieldHolder(FloatPrefEditorField.class, "floatField")); + put("int", new EditorFieldHolder(IntPrefEditorField.class, "intField")); + put("long", new EditorFieldHolder(LongPrefEditorField.class, "longField")); + put(CanonicalNameConstants.STRING, new EditorFieldHolder(StringPrefEditorField.class, "stringField")); + } + }; + + private JBlock constructorSuperBlock; + private JVar constructorContextParam; + private JFieldVar contextField; + private JDefinedClass editorClass; + + public SharedPrefHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + super(processHolder, annotatedElement); + + createEditorClass(); + createEditMethod(); + } + + @Override + protected void setGeneratedClass() throws Exception { + String annotatedComponentQualifiedName = annotatedElement.getQualifiedName().toString(); + String subComponentQualifiedName = annotatedComponentQualifiedName + ModelConstants.GENERATION_SUFFIX; + generatedClass = codeModel()._class(PUBLIC | FINAL, subComponentQualifiedName, ClassType.CLASS); + generatedClass._extends(SharedPreferencesHelper.class); + } + + private void createEditorClass() throws JClassAlreadyExistsException { + String interfaceSimpleName = annotatedElement.getSimpleName().toString(); + editorClass = generatedClass._class(JMod.PUBLIC | JMod.STATIC | JMod.FINAL, interfaceSimpleName + "Editor" + ModelConstants.GENERATION_SUFFIX); + editorClass._extends(processHolder.refClass(EditorHelper.class).narrow(editorClass)); + + createEditorConstructor(); + } + + private void createEditorConstructor() { + JMethod editorConstructor = editorClass.constructor(JMod.NONE); + JClass sharedPreferencesClass = processHolder.refClass("android.content.SharedPreferences"); + JVar sharedPreferencesParam = editorConstructor.param(sharedPreferencesClass, "sharedPreferences"); + editorConstructor.body().invoke("super").arg(sharedPreferencesParam); + } + + private void createEditMethod() { + JMethod editMethod = generatedClass.method(JMod.PUBLIC, editorClass, "edit"); + editMethod.body()._return(JExpr._new(editorClass).arg(JExpr.invoke("getSharedPreferences"))); + } + + public void createFieldMethod(Class prefFieldHelperClass, String fieldName, String fieldHelperMethodName, JExpression defaultValue) { + JMethod fieldMethod = generatedClass.method(JMod.PUBLIC, prefFieldHelperClass, fieldName); + fieldMethod.body()._return(JExpr.invoke(fieldHelperMethodName).arg(fieldName).arg(defaultValue)); + } + + public void createEditorFieldMethods(ExecutableElement method) { + String returnType = method.getReturnType().toString(); + EditorFieldHolder editorFieldHolder = EDITOR_FIELD_BY_TYPE.get(returnType); + JClass editorFieldClass = processHolder.refClass(editorFieldHolder.fieldClass); + String fieldName = method.getSimpleName().toString(); + JMethod editorFieldMethod = editorClass.method(JMod.PUBLIC, editorFieldClass.narrow(editorClass), fieldName); + editorFieldMethod.body()._return(JExpr.invoke(editorFieldHolder.fieldMethodName).arg(fieldName)); + } + + public JBlock getConstructorSuperBlock() { + if (constructorSuperBlock == null) { + setConstructor(); + } + return constructorSuperBlock; + } + + public JVar getConstructorContextParam() { + if (constructorContextParam == null) { + setConstructor(); + } + return constructorContextParam; + } + + private void setConstructor() { + JMethod constructor = generatedClass.constructor(JMod.PUBLIC); + constructorContextParam = constructor.param(classes().CONTEXT, "context"); + JBlock constructorBody = constructor.body(); + constructorSuperBlock = constructorBody.block(); + constructorBody.assign(JExpr._this().ref(getContextField()), constructorContextParam); + } + + public JFieldVar getContextField() { + if (contextField == null) { + setContextField(); + } + return contextField; + } + + protected void setContextField() { + contextField = generatedClass.field(JMod.PRIVATE, classes().CONTEXT, "context_"); + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SharedPrefValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SharedPrefValidator.java index 9bb60dd5d2..7ff78b4f81 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SharedPrefValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SharedPrefValidator.java @@ -15,18 +15,17 @@ */ package org.androidannotations.validation; -import java.util.List; +import org.androidannotations.annotations.sharedpreferences.SharedPref; +import org.androidannotations.helper.TargetAnnotationHelper; +import org.androidannotations.helper.ValidatorHelper; +import org.androidannotations.model.AnnotationElements; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; import javax.lang.model.element.ExecutableElement; import javax.lang.model.element.TypeElement; import javax.lang.model.util.Elements; - -import org.androidannotations.annotations.sharedpreferences.SharedPref; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; +import java.util.List; public class SharedPrefValidator implements ElementValidator { @@ -57,11 +56,9 @@ public boolean validate(Element element, AnnotationElements validatedElements) { for (Element memberElement : inheritedMembers) { if (!memberElement.getEnclosingElement().asType().toString().equals("java.lang.Object")) { - boolean isPrefMethod = validatorHelper.isPrefMethod(memberElement); - if (isPrefMethod) { - validatorHelper.hasCorrectDefaultAnnotation((ExecutableElement) memberElement); - } else { - valid.invalidate(); + validatorHelper.isPrefMethod(memberElement, valid); + if (valid.isValid()) { + validatorHelper.hasCorrectDefaultAnnotation((ExecutableElement) memberElement, valid); } } } From 0fdf190953071401f9d7a2dd7c5f9201853863a3 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Wed, 29 May 2013 17:00:23 +0200 Subject: [PATCH 13/86] Implement RoboGuiceHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/RoboGuiceHandler.java | 218 ++++++++++++++++++ .../holder/EActivityHolder.java | 149 +++++++++++- .../holder/HasViewChanged.java | 7 + .../holder/RoboGuiceHolder.java | 188 +++++++++++++++ 5 files changed, 558 insertions(+), 5 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasViewChanged.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 002ee692e4..e48c9d9c5a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -28,6 +28,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new EViewGroupHandler(processingEnvironment)); add(new EViewHandler(processingEnvironment)); add(new SharedPrefHandler(processingEnvironment)); + add(new RoboGuiceHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java new file mode 100644 index 0000000000..2ad286c751 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java @@ -0,0 +1,218 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.RoboGuice; +import org.androidannotations.holder.EActivityHolder; +import org.androidannotations.holder.RoboGuiceHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.ProcessHolder; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.AnnotationMirror; +import javax.lang.model.element.AnnotationValue; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +import static com.sun.codemodel.JExpr.*; + +public class RoboGuiceHandler extends BaseAnnotationHandler { + + public RoboGuiceHandler(ProcessingEnvironment processingEnvironment) { + super(RoboGuice.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.hasEActivity(element, validatedElements, valid); + + validatorHelper.hasRoboGuiceJars(element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EActivityHolder holder) { + RoboGuiceHolder roboGuiceHolder = holder.getRoboGuiceHolder(); + + holder.getGeneratedClass()._implements(holder.classes().INJECTOR_PROVIDER); + + JFieldVar scope = roboGuiceHolder.getScopeField(); + JFieldVar eventManager = roboGuiceHolder.getEventManagerField(); + JMethod getInjector = roboGuiceHolder.getGetInjector(); + listenerFields(element, holder); + + + beforeCreateMethod(holder, scope, eventManager, getInjector); + afterSetContentView(holder, scope, eventManager); + onRestartMethod(roboGuiceHolder, scope, eventManager); + onStartMethod(roboGuiceHolder, scope, eventManager); + onResumeMethod(roboGuiceHolder, scope, eventManager); + onPauseMethod(roboGuiceHolder, eventManager); + onNewIntentMethod(roboGuiceHolder, scope, eventManager); + onStopMethod(roboGuiceHolder, scope, eventManager); + onDestroyMethod(roboGuiceHolder, scope, eventManager); + onConfigurationChangedMethod(roboGuiceHolder, eventManager); + onContentChangedMethod(roboGuiceHolder, eventManager); + onActivityResultMethod(roboGuiceHolder, scope, eventManager); + } + + private void listenerFields(Element element, EActivityHolder holder) { + List listenerClasses = extractListenerClasses(element); + if (listenerClasses.size() > 0) { + int i = 1; + for (String listenerClassName : listenerClasses) { + JClass listenerClass = holder.refClass(listenerClassName); + JFieldVar listener = holder.getGeneratedClass().field(JMod.PRIVATE, listenerClass, "listener" + i + "_"); + listener.annotate(SuppressWarnings.class).param("value", "unused"); + listener.annotate(holder.classes().INJECT); + i++; + } + } + } + + private List extractListenerClasses(Element activityElement) { + + List annotationMirrors = activityElement.getAnnotationMirrors(); + + String annotationName = RoboGuice.class.getName(); + AnnotationValue action; + for (AnnotationMirror annotationMirror : annotationMirrors) { + if (annotationName.equals(annotationMirror.getAnnotationType().toString())) { + for (Map.Entry entry : annotationMirror.getElementValues().entrySet()) { + if ("value".equals(entry.getKey().getSimpleName().toString())) { + action = entry.getValue(); + + @SuppressWarnings("unchecked") + List values = (List) action.getValue(); + + List listenerClasses = new ArrayList(); + + for (Object value : values) { + listenerClasses.add(value.toString()); + } + return listenerClasses; + + } + } + } + } + return new ArrayList(0); + } + + private void beforeCreateMethod(EActivityHolder holder, JFieldVar scope, JFieldVar eventManager, JMethod getInjector) { + ProcessHolder.Classes classes = holder.classes(); + + JBlock body = holder.getInit().body(); + JVar injector = body.decl(classes.INJECTOR, "injector_", invoke(getInjector)); + body.assign(scope, invoke(injector, "getInstance").arg(classes.CONTEXT_SCOPE.dotclass())); + body.invoke(scope, "enter").arg(_this()); + body.invoke(injector, "injectMembers").arg(_this()); + body.assign(eventManager, invoke(injector, "getInstance").arg(classes.EVENT_MANAGER.dotclass())); + fireEvent(eventManager, body, holder.classes().ON_CREATE_EVENT, holder.getInitSavedInstanceParam()); + } + + private void afterSetContentView(EActivityHolder holder, JFieldVar scope, JFieldVar eventManager) { + JBlock onViewChanged = holder.getOnViewChangedHolder().body(); + onViewChanged.invoke(scope, "injectViews"); + fireEvent(eventManager, onViewChanged, holder.classes().ON_CONTENT_VIEW_AVAILABLE_EVENT); + } + + private void onRestartMethod(RoboGuiceHolder holder, JFieldVar scope, JFieldVar eventManager) { + JBlock onRestartBeforeSuperBlock = holder.getOnRestartBeforeSuperBlock(); + onRestartBeforeSuperBlock.invoke(scope, "enter").arg(_this()); + JBlock onRestartAfterSuperBlock = holder.getOnRestartAfterSuperBlock(); + fireEvent(eventManager, onRestartAfterSuperBlock, holder.classes().ON_RESTART_EVENT); + } + + private void onStartMethod(RoboGuiceHolder holder, JFieldVar scope, JFieldVar eventManager) { + JBlock onStartBeforeSuperBlock = holder.getOnStartBeforeSuperBlock(); + onStartBeforeSuperBlock.invoke(scope, "enter").arg(_this()); + JBlock onStartAfterSuperBlock = holder.getOnStartAfterSuperBlock(); + fireEvent(eventManager, onStartAfterSuperBlock, holder.classes().ON_START_EVENT); + } + + private void onResumeMethod(RoboGuiceHolder holder, JFieldVar scope, JFieldVar eventManager) { + JBlock onResumeBeforeSuperBlock = holder.getOnResumeBeforeSuperBlock(); + onResumeBeforeSuperBlock.invoke(scope, "enter").arg(_this()); + JBlock onResumeAfterSuperBlock = holder.getOnResumeAfterSuperBlock(); + fireEvent(eventManager, onResumeAfterSuperBlock, holder.classes().ON_RESUME_EVENT); + } + + private void onPauseMethod(RoboGuiceHolder holder, JFieldVar eventManager) { + JBlock onPauseAfterSuperBlock = holder.getOnPauseAfterSuperBlock(); + fireEvent(eventManager, onPauseAfterSuperBlock, holder.classes().ON_PAUSE_EVENT); + } + + private void onNewIntentMethod(RoboGuiceHolder holder, JFieldVar scope, JFieldVar eventManager) { + JBlock onNewIntentAfterSuperBlock = holder.getOnNewIntentAfterSuperBlock(); + onNewIntentAfterSuperBlock.invoke(scope, "enter").arg(_this()); + fireEvent(eventManager, onNewIntentAfterSuperBlock, holder.classes().ON_NEW_INTENT_EVENT); + } + + private void onStopMethod(RoboGuiceHolder holder, JFieldVar scope, JFieldVar eventManager) { + JBlock onStopBeforeSuperBlock = holder.getOnStopBeforeSuperBlock(); + onStopBeforeSuperBlock.invoke(scope, "enter").arg(_this()); + + JTryBlock tryBlock = onStopBeforeSuperBlock._try(); + fireEvent(eventManager, tryBlock.body(), holder.classes().ON_STOP_EVENT); + JBlock finallyBody = tryBlock._finally(); + + finallyBody.invoke(scope, "exit").arg(_this()); + finallyBody.invoke(_super(), "onStop"); + } + + private void onDestroyMethod(RoboGuiceHolder holder, JFieldVar scope, JFieldVar eventManager) { + JBlock onDestroyBeforeSuperBlock = holder.getOnDestroyBeforeSuperBlock(); + onDestroyBeforeSuperBlock.invoke(scope, "enter").arg(_this()); + + JTryBlock tryBlock = onDestroyBeforeSuperBlock._try(); + fireEvent(eventManager, tryBlock.body(), holder.classes().ON_DESTROY_EVENT); + JBlock finallyBody = tryBlock._finally(); + + finallyBody.invoke(eventManager, "clear").arg(_this()); + finallyBody.invoke(scope, "exit").arg(_this()); + finallyBody.invoke(scope, "dispose").arg(_this()); + finallyBody.invoke(_super(), "onDestroy"); + } + + private void onConfigurationChangedMethod(RoboGuiceHolder holder, JFieldVar eventManager) { + JVar currentConfig = holder.getCurrentConfig(); + JBlock onConfigurationChangedAfterSuperBlock = holder.getOnConfigurationChangedAfterSuperBlock(); + JExpression newConfig = holder.getNewConfig(); + fireEvent(eventManager, onConfigurationChangedAfterSuperBlock, holder.classes().ON_CONFIGURATION_CHANGED_EVENT, currentConfig, newConfig); + } + + private void onContentChangedMethod(RoboGuiceHolder holder, JFieldVar eventManager) { + JBlock onContentChangedAfterSuperBlock = holder.getOnContentChangedAfterSuperBlock(); + fireEvent(eventManager, onContentChangedAfterSuperBlock, holder.classes().ON_CONTENT_CHANGED_EVENT); + } + + private void onActivityResultMethod(RoboGuiceHolder holder, JFieldVar scope, JFieldVar eventManager) { + JBlock onActivityResultAfterSuperBlock = holder.getOnActivityResultAfterSuperBlock(); + JVar requestCode = holder.getRequestCode(); + JVar resultCode = holder.getResultCode(); + JVar data = holder.getData(); + + onActivityResultAfterSuperBlock.invoke(scope, "enter").arg(_this()); + + JTryBlock tryBlock = onActivityResultAfterSuperBlock._try(); + fireEvent(eventManager, tryBlock.body(), holder.classes().ON_ACTIVITY_RESULT_EVENT, requestCode, resultCode, data); + + JBlock finallyBody = tryBlock._finally(); + finallyBody.invoke(scope, "exit").arg(_this()); + } + + private void fireEvent(JFieldVar eventManager, JBlock body, JClass eventClass, JExpression... eventArguments) { + JInvocation newEvent = _new(eventClass); + for (JExpression eventArgument : eventArguments) { + newEvent.arg(eventArgument); + } + body.invoke(eventManager, "fire").arg(newEvent); + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java index eca78b7a5c..d6f6fdcf39 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java @@ -2,8 +2,12 @@ import com.sun.codemodel.*; import org.androidannotations.api.SdkVersionHelper; +import org.androidannotations.api.view.HasViews; +import org.androidannotations.api.view.OnViewChangedListener; +import org.androidannotations.api.view.OnViewChangedNotifier; import org.androidannotations.helper.*; import org.androidannotations.process.ProcessHolder; +import org.androidannotations.processing.ViewChangedHolder; import javax.lang.model.element.Element; import javax.lang.model.element.ExecutableElement; @@ -14,12 +18,11 @@ import java.util.ArrayList; import java.util.List; -import static com.sun.codemodel.JExpr._super; -import static com.sun.codemodel.JExpr._this; +import static com.sun.codemodel.JExpr.*; import static com.sun.codemodel.JMod.PRIVATE; import static com.sun.codemodel.JMod.PUBLIC; -public class EActivityHolder extends EComponentHolder implements HasIntentBuilder { +public class EActivityHolder extends EComponentHolder implements HasIntentBuilder, HasViewChanged { private ViewNotifierHelper viewNotifierHelper; private GreenDroidHelper greenDroidHelper; @@ -28,6 +31,8 @@ public class EActivityHolder extends EComponentHolder implements HasIntentBuilde private JVar initSavedInstanceParam; private JDefinedClass intentBuilderClass; private JFieldVar intentField; + private ViewChangedHolder viewChangedHolder; + private RoboGuiceHolder roboGuiceHolder; public EActivityHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); @@ -56,7 +61,7 @@ public JMethod getOnCreate() { return onCreate; } - private void setOnCreate() { + protected void setOnCreate() { onCreate = generatedClass.method(PUBLIC, codeModel().VOID, "onCreate"); onCreate.annotate(Override.class); JClass bundleClass = classes().BUNDLE; @@ -68,6 +73,118 @@ private void setOnCreate() { viewNotifierHelper.resetPreviousNotifier(onCreateBody, previousNotifier); } + protected void setOnStart() { + JMethod method = generatedClass.method(JMod.PUBLIC, codeModel().VOID, "onStart"); + method.annotate(Override.class); + JBlock body = method.body(); + roboGuiceHolder.onStartBeforeSuperBlock = body.block(); + body.invoke(_super(), method); + roboGuiceHolder.onStartAfterSuperBlock = body.block(); + } + + protected void setOnRestart() { + JMethod method = generatedClass.method(JMod.PUBLIC, codeModel().VOID, "onRestart"); + method.annotate(Override.class); + JBlock body = method.body(); + roboGuiceHolder.onRestartBeforeSuperBlock = body.block(); + body.invoke(_super(), method); + roboGuiceHolder.onRestartAfterSuperBlock = body.block(); + } + + protected void setOnResume() { + JMethod method = generatedClass.method(JMod.PUBLIC, codeModel().VOID, "onResume"); + method.annotate(Override.class); + JBlock body = method.body(); + roboGuiceHolder.onResumeBeforeSuperBlock = body.block(); + body.invoke(_super(), method); + roboGuiceHolder.onResumeAfterSuperBlock = body.block(); + } + + protected void setOnPause() { + JMethod method = generatedClass.method(JMod.PUBLIC, codeModel().VOID, "onPause"); + method.annotate(Override.class); + JBlock body = method.body(); + body.invoke(_super(), method); + roboGuiceHolder.onPauseAfterSuperBlock = body.block(); + } + + protected void setOnNewIntent() { + JMethod method = generatedClass.method(JMod.PUBLIC, codeModel().VOID, "onNewIntent"); + method.annotate(Override.class); + JVar intent = method.param(classes().INTENT, "intent"); + JBlock body = method.body(); + body.invoke(_super(), method).arg(intent); + roboGuiceHolder.onNewIntentAfterSuperBlock = body.block(); + } + + protected void setOnStop() { + JMethod method = generatedClass.method(JMod.PUBLIC, codeModel().VOID, "onStop"); + method.annotate(Override.class); + JBlock body = method.body(); + roboGuiceHolder.onStopBeforeSuperBlock = body.block(); + body.invoke(_super(), method); + } + + protected void setOnDestroy() { + JMethod method = generatedClass.method(JMod.PUBLIC, codeModel().VOID, "onDestroy"); + method.annotate(Override.class); + JBlock body = method.body(); + roboGuiceHolder.onDestroyBeforeSuperBlock = body.block(); + body.invoke(_super(), method); + } + + protected void setOnConfigurationChanged() { + JMethod method = generatedClass.method(JMod.PUBLIC, codeModel().VOID, "onConfigurationChanged"); + method.annotate(Override.class); + JClass configurationClass = classes().CONFIGURATION; + JVar newConfig = method.param(configurationClass, "newConfig"); + roboGuiceHolder.newConfig = newConfig; + JBlock body = method.body(); + roboGuiceHolder.currentConfig = body.decl(configurationClass, "currentConfig", JExpr.invoke("getResources").invoke("getConfiguration")); + body.invoke(_super(), method).arg(newConfig); + roboGuiceHolder.onConfigurationChangedAfterSuperBlock = body.block(); + } + + protected void setOnContentChanged() { + JMethod method = generatedClass.method(JMod.PUBLIC, codeModel().VOID, "onContentChanged"); + method.annotate(Override.class); + JBlock body = method.body(); + body.invoke(_super(), method); + roboGuiceHolder.onContentChangedAfterSuperBlock = body.block(); + } + + protected void setOnActivityResult() { + JMethod method = generatedClass.method(JMod.PUBLIC, codeModel().VOID, "onActivityResult"); + method.annotate(Override.class); + JVar requestCode = method.param(codeModel().INT, "requestCode"); + JVar resultCode = method.param(codeModel().INT, "resultCode"); + JVar data = method.param(classes().INTENT, "data"); + JBlock body = method.body(); + body.invoke(_super(), method).arg(requestCode).arg(resultCode).arg(data); + roboGuiceHolder.onActivityResultAfterSuperBlock = body.block(); + roboGuiceHolder.requestCode = requestCode; + roboGuiceHolder.resultCode = requestCode; + roboGuiceHolder.data = data; + } + + @Override + public ViewChangedHolder getOnViewChangedHolder() { + if (viewChangedHolder == null) { + setViewChangedHolder(); + } + return viewChangedHolder; + } + + private void setViewChangedHolder() { + generatedClass._implements(OnViewChangedListener.class); + JMethod onViewChanged = generatedClass.method(PUBLIC, codeModel().VOID, "onViewChanged"); + onViewChanged.annotate(Override.class); + JVar onViewChangedHasViewsParam = onViewChanged.param(HasViews.class, "hasViews"); + JClass notifierClass = refClass(OnViewChangedNotifier.class); + getInit().body().staticInvoke(notifierClass, "registerOnViewChangedListener").arg(_this()); + viewChangedHolder = new ViewChangedHolder(onViewChanged, onViewChangedHasViewsParam); + } + public JMethod getSetContentViewLayout() { if (setContentViewLayout == null) { setSetContentView(); @@ -112,7 +229,6 @@ public JVar getInitSavedInstanceParam() { return initSavedInstanceParam; } - private boolean usesGreenDroid() { if (greenDroidHelper == null) { greenDroidHelper = new GreenDroidHelper(processingEnvironment()); @@ -203,4 +319,27 @@ public void setIntentField(JFieldVar intentField) { public JFieldVar getIntentField() { return intentField; } + + public RoboGuiceHolder getRoboGuiceHolder() { + if (roboGuiceHolder == null) { + roboGuiceHolder = new RoboGuiceHolder(this); + } + return roboGuiceHolder; + } + + protected void setScopeField() { + roboGuiceHolder.scope = getGeneratedClass().field(JMod.PRIVATE, classes().CONTEXT_SCOPE, "scope_"); + } + + protected void setEventManagerField() { + roboGuiceHolder.eventManager = generatedClass.field(JMod.PRIVATE, classes().EVENT_MANAGER, "eventManager_"); + } + + public void setGetInjector() { + JMethod method = generatedClass.method(JMod.PUBLIC, classes().INJECTOR, "getInjector"); + method.annotate(Override.class); + JExpression castApplication = cast(classes().INJECTOR_PROVIDER, invoke("getApplication")); + method.body()._return(castApplication.invoke("getInjector")); + roboGuiceHolder.getInjector = method; + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasViewChanged.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasViewChanged.java new file mode 100644 index 0000000000..0cad013ec7 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasViewChanged.java @@ -0,0 +1,7 @@ +package org.androidannotations.holder; + +import org.androidannotations.processing.ViewChangedHolder; + +public interface HasViewChanged extends GeneratedClassHolder { + ViewChangedHolder getOnViewChangedHolder(); +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java new file mode 100644 index 0000000000..de38e8dfb1 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java @@ -0,0 +1,188 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JFieldVar; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JVar; +import org.androidannotations.process.ProcessHolder; + +public class RoboGuiceHolder { + + private EActivityHolder holder; + protected JFieldVar scope; + protected JFieldVar eventManager; + protected JMethod getInjector; + protected JBlock onRestartBeforeSuperBlock; + protected JBlock onRestartAfterSuperBlock; + protected JBlock onStartBeforeSuperBlock; + protected JBlock onStartAfterSuperBlock; + protected JBlock onResumeBeforeSuperBlock; + protected JBlock onResumeAfterSuperBlock; + protected JBlock onPauseAfterSuperBlock; + protected JBlock onNewIntentAfterSuperBlock; + protected JBlock onStopBeforeSuperBlock; + protected JBlock onDestroyBeforeSuperBlock; + protected JVar newConfig; + protected JVar currentConfig; + protected JBlock onConfigurationChangedAfterSuperBlock; + protected JBlock onContentChangedAfterSuperBlock; + protected JBlock onActivityResultAfterSuperBlock; + protected JVar requestCode; + protected JVar resultCode; + protected JVar data; + + public RoboGuiceHolder(EActivityHolder holder) { + this.holder = holder; + } + + public ProcessHolder.Classes classes() { + return holder.classes(); + } + + public JFieldVar getEventManagerField() { + if (eventManager == null) { + holder.setEventManagerField(); + } + return eventManager; + } + + public JFieldVar getScopeField() { + if (scope == null) { + holder.setScopeField(); + } + return scope; + } + + public JMethod getGetInjector() { + if (getInjector == null) { + holder.setGetInjector(); + } + return getInjector; + } + + public JBlock getOnRestartBeforeSuperBlock() { + if (onRestartBeforeSuperBlock == null) { + holder.setOnRestart(); + } + return onRestartBeforeSuperBlock; + } + + public JBlock getOnRestartAfterSuperBlock() { + if (onRestartAfterSuperBlock == null) { + holder.setOnRestart(); + } + return onRestartAfterSuperBlock; + } + + public JBlock getOnStartBeforeSuperBlock() { + if (onStartBeforeSuperBlock == null) { + holder.setOnStart(); + } + return onStartBeforeSuperBlock; + } + + public JBlock getOnStartAfterSuperBlock() { + if (onStartAfterSuperBlock == null) { + holder.setOnStart(); + } + return onStartAfterSuperBlock; + } + + public JBlock getOnResumeBeforeSuperBlock() { + if (onResumeBeforeSuperBlock == null) { + holder.setOnResume(); + } + return onResumeBeforeSuperBlock; + } + + public JBlock getOnResumeAfterSuperBlock() { + if (onResumeAfterSuperBlock == null) { + holder.setOnResume(); + } + return onResumeAfterSuperBlock; + } + + public JBlock getOnPauseAfterSuperBlock() { + if (onPauseAfterSuperBlock == null) { + holder.setOnPause(); + } + return onPauseAfterSuperBlock; + } + + public JBlock getOnNewIntentAfterSuperBlock() { + if (onNewIntentAfterSuperBlock == null) { + holder.setOnNewIntent(); + } + return onNewIntentAfterSuperBlock; + } + + public JBlock getOnStopBeforeSuperBlock() { + if (onStopBeforeSuperBlock == null) { + holder.setOnStop(); + } + return onStopBeforeSuperBlock; + } + + public JBlock getOnDestroyBeforeSuperBlock() { + if (onDestroyBeforeSuperBlock == null) { + holder.setOnDestroy(); + } + return onDestroyBeforeSuperBlock; + } + + public JVar getNewConfig() { + if (newConfig == null) { + holder.setOnConfigurationChanged(); + } + return newConfig; + } + + public JVar getCurrentConfig() { + if (currentConfig == null) { + holder.setOnConfigurationChanged(); + } + return currentConfig; + } + + public JBlock getOnConfigurationChangedAfterSuperBlock() { + if (onConfigurationChangedAfterSuperBlock == null) { + holder.setOnConfigurationChanged(); + } + return onConfigurationChangedAfterSuperBlock; + } + + public JBlock getOnContentChangedAfterSuperBlock() { + if (onContentChangedAfterSuperBlock == null) { + holder.setOnContentChanged(); + } + return onContentChangedAfterSuperBlock; + } + + public JBlock getOnActivityResultAfterSuperBlock() { + if (onActivityResultAfterSuperBlock == null) { + holder.setOnActivityResult(); + } + return onActivityResultAfterSuperBlock; + } + + public JVar getRequestCode() { + if (requestCode == null) { + holder.setOnActivityResult(); + } + return requestCode; + } + + public JVar getResultCode() { + if (resultCode == null) { + holder.setOnActivityResult(); + } + return resultCode; + } + + public JVar getData() { + if (data == null) { + holder.setOnActivityResult(); + } + return data; + } +} From 20d6da444b3a1f71d0445a95bac487fb22e97db1 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Wed, 29 May 2013 17:11:01 +0200 Subject: [PATCH 14/86] Implement PrefHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/PrefHandler.java | 75 +++++++++++++++++++ 2 files changed, 76 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index e48c9d9c5a..7836a76910 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -28,6 +28,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new EViewGroupHandler(processingEnvironment)); add(new EViewHandler(processingEnvironment)); add(new SharedPrefHandler(processingEnvironment)); + add(new PrefHandler(processingEnvironment)); add(new RoboGuiceHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java new file mode 100644 index 0000000000..a033c37829 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java @@ -0,0 +1,75 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JFieldRef; +import org.androidannotations.annotations.sharedpreferences.Pref; +import org.androidannotations.annotations.sharedpreferences.SharedPref; +import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; +import javax.lang.model.type.ErrorType; +import javax.lang.model.type.TypeKind; +import javax.lang.model.type.TypeMirror; +import java.util.Set; + +import static org.androidannotations.helper.ModelConstants.GENERATION_SUFFIX; + +public class PrefHandler extends BaseAnnotationHandler { + + public PrefHandler(ProcessingEnvironment processingEnvironment) { + super(Pref.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); + + validatorHelper.isNotPrivate(element, valid); + + validatorHelper.isSharedPreference(element, validatedElements, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EComponentHolder holder) { + + String fieldName = element.getSimpleName().toString(); + + TypeMirror fieldTypeMirror = element.asType(); + + String fieldType = fieldTypeMirror.toString(); + if (fieldTypeMirror instanceof ErrorType || fieldTypeMirror.getKind() == TypeKind.ERROR) { + String elementTypeName = fieldTypeMirror.toString(); + String prefTypeName = elementTypeName.substring(0, elementTypeName.length() - GENERATION_SUFFIX.length()); + Set sharedPrefElements = validatedModel.getRootAnnotatedElements(SharedPref.class.getName()); + + for (Element sharedPrefElement : sharedPrefElements) { + TypeElement sharedPrefTypeElement = (TypeElement) sharedPrefElement; + + String sharedPrefSimpleName = sharedPrefTypeElement.getSimpleName().toString(); + String sharedPrefQualifiedName = sharedPrefTypeElement.getQualifiedName().toString(); + + if (sharedPrefSimpleName.equals(prefTypeName)) { + fieldType = sharedPrefQualifiedName + GENERATION_SUFFIX; + break; + } + } + + } + + JBlock methodBody = holder.getInit().body(); + + JFieldRef field = JExpr.ref(fieldName); + + methodBody.assign(field, JExpr._new(holder.refClass(fieldType)).arg(holder.getContextRef())); + + } +} From ba5d5e3136b6199aa61e05f5f0d6663047542e92 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Wed, 29 May 2013 17:32:24 +0200 Subject: [PATCH 15/86] Implement ViewByIdHandler Conflicts: AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewGroupHolder.java AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java --- .../handler/AnnotationHandlers.java | 2 + .../handler/ViewByIdHandler.java | 67 +++++++++++++++++++ .../helper/ValidatorHelper.java | 7 ++ .../helper/ViewNotifierHelper.java | 6 +- .../holder/EActivityHolder.java | 12 +--- .../holder/EBeanHolder.java | 15 ++++- .../holder/EFragmentHolder.java | 15 ++++- .../holder/EViewHolder.java | 15 ++++- .../holder/HasViewChanged.java | 2 - .../holder/ViewChangedHolder.java | 58 ++++++++++++++++ 10 files changed, 178 insertions(+), 21 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/ViewChangedHolder.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 7836a76910..a4380d12f6 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -30,6 +30,8 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new SharedPrefHandler(processingEnvironment)); add(new PrefHandler(processingEnvironment)); add(new RoboGuiceHandler(processingEnvironment)); + add(new ViewByIdHandler(processingEnvironment)); + add(new AfterInjectHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java new file mode 100644 index 0000000000..fa84008ade --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java @@ -0,0 +1,67 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JFieldRef; +import org.androidannotations.annotations.ViewById; +import org.androidannotations.helper.AndroidManifest; +import org.androidannotations.helper.IdAnnotationHelper; +import org.androidannotations.helper.IdValidatorHelper; +import org.androidannotations.holder.HasViewChanged; +import org.androidannotations.holder.ViewChangedHolder; +import org.androidannotations.model.AndroidSystemServices; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.rclass.IRClass; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.type.TypeMirror; + +import static com.sun.codemodel.JExpr.cast; +import static com.sun.codemodel.JExpr.ref; + +public class ViewByIdHandler extends BaseAnnotationHandler { + + private IdAnnotationHelper annotationHelper; + + public ViewByIdHandler(ProcessingEnvironment processingEnvironment) { + super(ViewById.class, processingEnvironment); + } + + @Override + public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) { + super.setAndroidEnvironment(rClass, androidSystemServices, androidManifest); + annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); + + validatorHelper.isDeclaredType(element, valid); + + validatorHelper.extendsView(element, valid); + + validatorHelper.resIdsExist(element, IRClass.Res.ID, IdValidatorHelper.FallbackStrategy.USE_ELEMENT_NAME, valid); + + validatorHelper.isNotPrivate(element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, HasViewChanged holder) { + String fieldName = element.getSimpleName().toString(); + + TypeMirror uiFieldTypeMirror = element.asType(); + String typeQualifiedName = uiFieldTypeMirror.toString(); + + JFieldRef idRef = annotationHelper.extractOneAnnotationFieldRef(holder, element, IRClass.Res.ID, true); + + ViewChangedHolder onViewChanged = holder.getOnViewChangedHolder(); + JBlock methodBody = onViewChanged.body(); + methodBody.assign(ref(fieldName), cast(holder.refClass(typeQualifiedName), onViewChanged.findViewById(idRef))); + } +} 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 bd4378d9df..f1c9a1ae8b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java @@ -663,6 +663,13 @@ public void androidService(AndroidSystemServices androidSystemServices, Element } } + public void isDeclaredType(Element element, IsValid valid) { + if (!(element.asType() instanceof DeclaredType)) { + valid.invalidate(); + annotationHelper.printAnnotationError(element, "%s can only be used on a field which is a declared type"); + } + } + 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/ViewNotifierHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ViewNotifierHelper.java index fc2614763d..4e9e248f86 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ViewNotifierHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ViewNotifierHelper.java @@ -8,9 +8,7 @@ import org.androidannotations.api.view.OnViewChangedNotifier; import org.androidannotations.holder.EComponentHolder; -import static com.sun.codemodel.JExpr._new; -import static com.sun.codemodel.JExpr._null; -import static com.sun.codemodel.JExpr._this; +import static com.sun.codemodel.JExpr.*; import static com.sun.codemodel.JMod.FINAL; import static com.sun.codemodel.JMod.PRIVATE; @@ -51,8 +49,6 @@ public void resetPreviousNotifier(JBlock block, JVar previousNotifier) { public void wrapInitWithNotifier() { JBlock initBlock = holder.getInit().body(); JVar previousNotifier = replacePreviousNotifier(initBlock); - // TODO: see the effect of this - // initBody = initBody.block(); resetPreviousNotifier(initBlock, previousNotifier); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java index d6f6fdcf39..0c491a22ec 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java @@ -2,12 +2,8 @@ import com.sun.codemodel.*; import org.androidannotations.api.SdkVersionHelper; -import org.androidannotations.api.view.HasViews; -import org.androidannotations.api.view.OnViewChangedListener; -import org.androidannotations.api.view.OnViewChangedNotifier; import org.androidannotations.helper.*; import org.androidannotations.process.ProcessHolder; -import org.androidannotations.processing.ViewChangedHolder; import javax.lang.model.element.Element; import javax.lang.model.element.ExecutableElement; @@ -176,13 +172,7 @@ public ViewChangedHolder getOnViewChangedHolder() { } private void setViewChangedHolder() { - generatedClass._implements(OnViewChangedListener.class); - JMethod onViewChanged = generatedClass.method(PUBLIC, codeModel().VOID, "onViewChanged"); - onViewChanged.annotate(Override.class); - JVar onViewChangedHasViewsParam = onViewChanged.param(HasViews.class, "hasViews"); - JClass notifierClass = refClass(OnViewChangedNotifier.class); - getInit().body().staticInvoke(notifierClass, "registerOnViewChangedListener").arg(_this()); - viewChangedHolder = new ViewChangedHolder(onViewChanged, onViewChangedHasViewsParam); + viewChangedHolder = ViewChangedHolder.createViewChangedHolder(this); } public JMethod getSetContentViewLayout() { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java index d6a2a561cd..4018b13577 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java @@ -17,11 +17,12 @@ import static com.sun.codemodel.JMod.*; import static org.androidannotations.helper.ModelConstants.GENERATION_SUFFIX; -public class EBeanHolder extends EComponentHolder { +public class EBeanHolder extends EComponentHolder implements HasViewChanged { public static final String GET_INSTANCE_METHOD_NAME = "getInstance" + GENERATION_SUFFIX; private ViewNotifierHelper viewNotifierHelper; + private ViewChangedHolder viewChangedHolder; private JFieldVar contextField; private JMethod constructor; @@ -96,4 +97,16 @@ public void createRebindMethod() { body.invoke(getInit()); } + @Override + public ViewChangedHolder getOnViewChangedHolder() { + if (viewChangedHolder == null) { + setViewChangedHolder(); + } + return viewChangedHolder; + } + + private void setViewChangedHolder() { + viewChangedHolder = ViewChangedHolder.createViewChangedHolder(this); + } + } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java index e8ed285f9a..a46ec74b75 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java @@ -10,7 +10,7 @@ import static com.sun.codemodel.JExpr.*; import static com.sun.codemodel.JMod.*; -public class EFragmentHolder extends EComponentHolder { +public class EFragmentHolder extends EComponentHolder implements HasViewChanged { private ViewNotifierHelper viewNotifierHelper; private JFieldVar contentView; @@ -19,6 +19,7 @@ public class EFragmentHolder extends EComponentHolder { private JVar container; private JDefinedClass fragmentBuilderClass; private JFieldVar fragmentArgumentsBuilderField; + private ViewChangedHolder viewChangedHolder; public EFragmentHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); @@ -115,6 +116,18 @@ private void setContentView() { contentView = generatedClass.field(PRIVATE, classes().VIEW, "contentView_"); } + @Override + public ViewChangedHolder getOnViewChangedHolder() { + if (viewChangedHolder == null) { + setViewChangedHolder(); + } + return viewChangedHolder; + } + + private void setViewChangedHolder() { + viewChangedHolder = ViewChangedHolder.createViewChangedHolder(this); + } + private void setOnCreateView() { JMethod onCreateView = generatedClass.method(PUBLIC, classes().VIEW, "onCreateView"); onCreateView.annotate(Override.class); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java index d97dfc376a..92c277d76d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java @@ -13,7 +13,7 @@ import static com.sun.codemodel.JMod.*; import static javax.lang.model.element.ElementKind.CONSTRUCTOR; -public class EViewHolder extends EComponentHolder { +public class EViewHolder extends EComponentHolder implements HasViewChanged { protected static final String ALREADY_INFLATED_COMMENT = "" // + + "The mAlreadyInflated_ hack is needed because of an Android bug\n" // + @@ -32,6 +32,7 @@ public class EViewHolder extends EComponentHolder { protected ViewNotifierHelper viewNotifierHelper; protected JMethod onFinishInflate; protected JFieldVar alreadyInflated; + private ViewChangedHolder viewChangedHolder; public EViewHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); @@ -134,4 +135,16 @@ public JFieldVar getAlreadyInflated() { private void setAlreadyInflated() { alreadyInflated = generatedClass.field(PRIVATE, JType.parse(codeModel(), "boolean"), "alreadyInflated_", JExpr.FALSE); } + + @Override + public ViewChangedHolder getOnViewChangedHolder() { + if (viewChangedHolder == null) { + setViewChangedHolder(); + } + return viewChangedHolder; + } + + private void setViewChangedHolder() { + viewChangedHolder = ViewChangedHolder.createViewChangedHolder(this); + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasViewChanged.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasViewChanged.java index 0cad013ec7..641ea1344d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasViewChanged.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasViewChanged.java @@ -1,7 +1,5 @@ package org.androidannotations.holder; -import org.androidannotations.processing.ViewChangedHolder; - public interface HasViewChanged extends GeneratedClassHolder { ViewChangedHolder getOnViewChangedHolder(); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/ViewChangedHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/ViewChangedHolder.java new file mode 100644 index 0000000000..f1a9e21f0b --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/ViewChangedHolder.java @@ -0,0 +1,58 @@ +/** + * Copyright (C) 2010-2013 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.holder; + +import com.sun.codemodel.*; +import org.androidannotations.api.view.HasViews; +import org.androidannotations.api.view.OnViewChangedListener; +import org.androidannotations.api.view.OnViewChangedNotifier; + +import static com.sun.codemodel.JExpr._this; +import static com.sun.codemodel.JExpr.invoke; +import static com.sun.codemodel.JMod.PUBLIC; + +public class ViewChangedHolder { + + public static ViewChangedHolder createViewChangedHolder(EComponentHolder holder) { + holder.getGeneratedClass()._implements(OnViewChangedListener.class); + JMethod onViewChanged = holder.getGeneratedClass().method(PUBLIC, holder.codeModel().VOID, "onViewChanged"); + onViewChanged.annotate(Override.class); + JVar onViewChangedHasViewsParam = onViewChanged.param(HasViews.class, "hasViews"); + JClass notifierClass = holder.refClass(OnViewChangedNotifier.class); + holder.getInit().body().staticInvoke(notifierClass, "registerOnViewChangedListener").arg(_this()); + return new ViewChangedHolder(onViewChanged, onViewChangedHasViewsParam); + } + + private JMethod onViewChanged; + private JVar onViewChangedHasViewsParam; + + public ViewChangedHolder(JMethod onViewChanged, JVar onViewChangedHasViewsParam) { + this.onViewChanged = onViewChanged; + this.onViewChangedHasViewsParam = onViewChangedHasViewsParam; + } + + public JBlock body() { + return onViewChanged.body(); + } + + public JInvocation findViewById(JFieldRef idRef) { + JInvocation findViewById = invoke(onViewChangedHasViewsParam, "findViewById"); + findViewById.arg(idRef); + return findViewById; + + } + +} From 84c38e1b5cda84fb8fc2e8826bf4a688f5ee8540 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Wed, 29 May 2013 18:23:30 +0200 Subject: [PATCH 16/86] Implement FragmentByIdHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/FragmentByIdHandler.java | 77 +++++++++++++++++++ .../helper/FindFragmentHelper.java | 43 +++++++++++ .../holder/EActivityHolder.java | 34 ++++++++ .../holder/EBeanHolder.java | 26 +++++++ .../holder/EFragmentHolder.java | 27 +++++++ .../holder/EViewHolder.java | 27 +++++++ .../holder/HasViewChanged.java | 4 + 8 files changed, 239 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/FindFragmentHelper.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index a4380d12f6..64aa884478 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -31,6 +31,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new PrefHandler(processingEnvironment)); add(new RoboGuiceHandler(processingEnvironment)); add(new ViewByIdHandler(processingEnvironment)); + add(new FragmentByIdHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java new file mode 100644 index 0000000000..c11b69049d --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java @@ -0,0 +1,77 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JFieldRef; +import com.sun.codemodel.JMethod; +import org.androidannotations.annotations.FragmentById; +import org.androidannotations.helper.AndroidManifest; +import org.androidannotations.helper.CanonicalNameConstants; +import org.androidannotations.helper.IdAnnotationHelper; +import org.androidannotations.helper.IdValidatorHelper; +import org.androidannotations.holder.HasViewChanged; +import org.androidannotations.model.AndroidSystemServices; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.rclass.IRClass; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; +import javax.lang.model.type.TypeMirror; + +import static com.sun.codemodel.JExpr.*; + +public class FragmentByIdHandler extends BaseAnnotationHandler { + + private IdAnnotationHelper annotationHelper; + + public FragmentByIdHandler(ProcessingEnvironment processingEnvironment) { + super(FragmentById.class, processingEnvironment); + } + + @Override + public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) { + super.setAndroidEnvironment(rClass, androidSystemServices, androidManifest); + annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); + + validatorHelper.extendsFragment(element, valid); + + validatorHelper.resIdsExist(element, IRClass.Res.ID, IdValidatorHelper.FallbackStrategy.USE_ELEMENT_NAME, valid); + + validatorHelper.isNotPrivate(element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, HasViewChanged holder) { + + TypeMirror elementType = element.asType(); + String typeQualifiedName = elementType.toString(); + TypeElement nativeFragmentElement = annotationHelper.typeElementFromQualifiedName(CanonicalNameConstants.FRAGMENT); + boolean isNativeFragment = nativeFragmentElement != null && annotationHelper.isSubtype(elementType, nativeFragmentElement.asType()); + + JMethod findFragmentById; + if (isNativeFragment) { + findFragmentById = holder.getFindNativeFragmentById(); + } else { + findFragmentById = holder.getFindSupportFragmentById(); + } + + String fieldName = element.getSimpleName().toString(); + + JFieldRef idRef = annotationHelper.extractOneAnnotationFieldRef(holder, element, IRClass.Res.ID, true); + + JBlock methodBody = holder.getOnViewChangedHolder().body(); + + methodBody.assign(ref(fieldName), cast(holder.refClass(typeQualifiedName), invoke(findFragmentById).arg(idRef))); + + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/FindFragmentHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/FindFragmentHelper.java new file mode 100644 index 0000000000..d1d5fb50e8 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/FindFragmentHelper.java @@ -0,0 +1,43 @@ +package org.androidannotations.helper; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JVar; +import org.androidannotations.holder.EComponentHolder; + +import static com.sun.codemodel.JExpr._null; +import static com.sun.codemodel.JExpr.cast; +import static com.sun.codemodel.JMod.PRIVATE; + +public class FindFragmentHelper { + + public static JMethod createFindNativeFragmentById(EComponentHolder holder) { + JMethod method = holder.getGeneratedClass().method(PRIVATE, holder.classes().FRAGMENT, "findNativeFragmentById"); + JVar idParam = method.param(holder.codeModel().INT, "id"); + + JBlock body = method.body(); + + body._if(holder.getContextRef()._instanceof(holder.classes().ACTIVITY).not())._then()._return(_null()); + + JVar activityVar = body.decl(holder.classes().ACTIVITY, "activity_", cast(holder.classes().ACTIVITY, holder.getContextRef())); + + body._return(activityVar.invoke("getFragmentManager").invoke("findFragmentById").arg(idParam)); + + return method; + } + + public static JMethod createFindSupportFragmentById(EComponentHolder holder) { + JMethod method = holder.getGeneratedClass().method(PRIVATE, holder.classes().SUPPORT_V4_FRAGMENT, "findSupportFragmentById"); + JVar idParam = method.param(holder.codeModel().INT, "id"); + + JBlock body = method.body(); + + body._if(holder.getContextRef()._instanceof(holder.classes().FRAGMENT_ACTIVITY).not())._then()._return(_null()); + + JVar activityVar = body.decl(holder.classes().FRAGMENT_ACTIVITY, "activity_", cast(holder.classes().FRAGMENT_ACTIVITY, holder.getContextRef())); + + body._return(activityVar.invoke("getSupportFragmentManager").invoke("findFragmentById").arg(idParam)); + + return method; + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java index 0c491a22ec..9c3f608228 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java @@ -28,6 +28,8 @@ public class EActivityHolder extends EComponentHolder implements HasIntentBuilde private JDefinedClass intentBuilderClass; private JFieldVar intentField; private ViewChangedHolder viewChangedHolder; + private JMethod findNativeFragmentById; + private JMethod findSupportFragmentById; private RoboGuiceHolder roboGuiceHolder; public EActivityHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { @@ -175,6 +177,38 @@ private void setViewChangedHolder() { viewChangedHolder = ViewChangedHolder.createViewChangedHolder(this); } + @Override + public JMethod getFindNativeFragmentById() { + if (findNativeFragmentById == null) { + setFindNativeFragmentById(); + } + return findNativeFragmentById; + } + + private void setFindNativeFragmentById() { + JMethod method = generatedClass.method(PRIVATE, classes().FRAGMENT, "findNativeFragmentById"); + JVar idParam = method.param(codeModel().INT, "id"); + JBlock body = method.body(); + body._return(invoke("getFragmentManager").invoke("findFragmentById").arg(idParam)); + findNativeFragmentById = method; + } + + @Override + public JMethod getFindSupportFragmentById() { + if (findSupportFragmentById == null) { + setFindSupportFragmentById(); + } + return findSupportFragmentById; + } + + private void setFindSupportFragmentById() { + JMethod method = generatedClass.method(PRIVATE, classes().SUPPORT_V4_FRAGMENT, "findSupportFragmentById"); + JVar idParam = method.param(codeModel().INT, "id"); + JBlock body = method.body(); + body._return(invoke("getSupportFragmentManager").invoke("findFragmentById").arg(idParam)); + findSupportFragmentById = method; + } + public JMethod getSetContentViewLayout() { if (setContentViewLayout == null) { setSetContentView(); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java index 4018b13577..a0802e11af 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java @@ -4,6 +4,7 @@ import com.sun.codemodel.JFieldVar; import com.sun.codemodel.JMethod; import com.sun.codemodel.JVar; +import org.androidannotations.helper.FindFragmentHelper; import org.androidannotations.helper.ViewNotifierHelper; import org.androidannotations.process.ProcessHolder; @@ -25,6 +26,8 @@ public class EBeanHolder extends EComponentHolder implements HasViewChanged { private ViewChangedHolder viewChangedHolder; private JFieldVar contextField; private JMethod constructor; + private JMethod findNativeFragmentById; + private JMethod findSupportFragmentById; public EBeanHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); @@ -109,4 +112,27 @@ private void setViewChangedHolder() { viewChangedHolder = ViewChangedHolder.createViewChangedHolder(this); } + @Override + public JMethod getFindNativeFragmentById() { + if (findNativeFragmentById == null) { + setFindNativeFragmentById(); + } + return findNativeFragmentById; + } + + private void setFindNativeFragmentById() { + findNativeFragmentById = FindFragmentHelper.createFindNativeFragmentById(this); + } + + @Override + public JMethod getFindSupportFragmentById() { + if (findSupportFragmentById == null) { + setFindSupportFragmentById(); + } + return findSupportFragmentById; + } + + private void setFindSupportFragmentById() { + findSupportFragmentById = FindFragmentHelper.createFindSupportFragmentById(this); + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java index a46ec74b75..9f61d6b1a4 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java @@ -1,6 +1,7 @@ package org.androidannotations.holder; import com.sun.codemodel.*; +import org.androidannotations.helper.FindFragmentHelper; import org.androidannotations.helper.HoloEverywhereHelper; import org.androidannotations.helper.ViewNotifierHelper; import org.androidannotations.process.ProcessHolder; @@ -20,6 +21,8 @@ public class EFragmentHolder extends EComponentHolder implements HasViewChanged private JDefinedClass fragmentBuilderClass; private JFieldVar fragmentArgumentsBuilderField; private ViewChangedHolder viewChangedHolder; + private JMethod findNativeFragmentById; + private JMethod findSupportFragmentById; public EFragmentHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); @@ -128,6 +131,30 @@ private void setViewChangedHolder() { viewChangedHolder = ViewChangedHolder.createViewChangedHolder(this); } + @Override + public JMethod getFindNativeFragmentById() { + if (findNativeFragmentById == null) { + setFindNativeFragmentById(); + } + return findNativeFragmentById; + } + + private void setFindNativeFragmentById() { + findNativeFragmentById = FindFragmentHelper.createFindNativeFragmentById(this); + } + + @Override + public JMethod getFindSupportFragmentById() { + if (findSupportFragmentById == null) { + setFindSupportFragmentById(); + } + return findSupportFragmentById; + } + + private void setFindSupportFragmentById() { + findSupportFragmentById = FindFragmentHelper.createFindSupportFragmentById(this); + } + private void setOnCreateView() { JMethod onCreateView = generatedClass.method(PUBLIC, classes().VIEW, "onCreateView"); onCreateView.annotate(Override.class); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java index 92c277d76d..804b5f056f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java @@ -1,6 +1,7 @@ package org.androidannotations.holder; import com.sun.codemodel.*; +import org.androidannotations.helper.FindFragmentHelper; import org.androidannotations.helper.ModelConstants; import org.androidannotations.helper.ViewNotifierHelper; import org.androidannotations.process.ProcessHolder; @@ -33,6 +34,8 @@ public class EViewHolder extends EComponentHolder implements HasViewChanged { protected JMethod onFinishInflate; protected JFieldVar alreadyInflated; private ViewChangedHolder viewChangedHolder; + private JMethod findNativeFragmentById; + private JMethod findSupportFragmentById; public EViewHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); @@ -147,4 +150,28 @@ public ViewChangedHolder getOnViewChangedHolder() { private void setViewChangedHolder() { viewChangedHolder = ViewChangedHolder.createViewChangedHolder(this); } + + @Override + public JMethod getFindNativeFragmentById() { + if (findNativeFragmentById == null) { + setFindNativeFragmentById(); + } + return findNativeFragmentById; + } + + private void setFindNativeFragmentById() { + findNativeFragmentById = FindFragmentHelper.createFindNativeFragmentById(this); + } + + @Override + public JMethod getFindSupportFragmentById() { + if (findSupportFragmentById == null) { + setFindSupportFragmentById(); + } + return findSupportFragmentById; + } + + private void setFindSupportFragmentById() { + findSupportFragmentById = FindFragmentHelper.createFindSupportFragmentById(this); + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasViewChanged.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasViewChanged.java index 641ea1344d..d71df1a0bd 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasViewChanged.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasViewChanged.java @@ -1,5 +1,9 @@ package org.androidannotations.holder; +import com.sun.codemodel.JMethod; + public interface HasViewChanged extends GeneratedClassHolder { ViewChangedHolder getOnViewChangedHolder(); + JMethod getFindNativeFragmentById(); + JMethod getFindSupportFragmentById(); } From 18a35bab3f200fa544227c27389432611c1b3891 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 30 May 2013 11:47:51 +0200 Subject: [PATCH 17/86] Implement FragmentByTagHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/FragmentByTagHandler.java | 73 +++++++++++++++++++ .../helper/FindFragmentHelper.java | 30 ++++++++ .../holder/EActivityHolder.java | 34 +++++++++ .../holder/EBeanHolder.java | 26 +++++++ .../holder/EFragmentHolder.java | 26 +++++++ .../holder/EViewHolder.java | 26 +++++++ .../holder/HasViewChanged.java | 2 + 8 files changed, 218 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 64aa884478..c77753939f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -32,6 +32,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new RoboGuiceHandler(processingEnvironment)); add(new ViewByIdHandler(processingEnvironment)); add(new FragmentByIdHandler(processingEnvironment)); + add(new FragmentByTagHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java new file mode 100644 index 0000000000..fd9e6fdc7d --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java @@ -0,0 +1,73 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JMethod; +import org.androidannotations.annotations.FragmentByTag; +import org.androidannotations.helper.AndroidManifest; +import org.androidannotations.helper.CanonicalNameConstants; +import org.androidannotations.helper.IdAnnotationHelper; +import org.androidannotations.holder.HasViewChanged; +import org.androidannotations.model.AndroidSystemServices; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.rclass.IRClass; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.type.TypeMirror; + +import static com.sun.codemodel.JExpr.*; + +public class FragmentByTagHandler extends BaseAnnotationHandler { + + private IdAnnotationHelper annotationHelper; + + public FragmentByTagHandler(ProcessingEnvironment processingEnvironment) { + super(FragmentByTag.class, processingEnvironment); + } + + @Override + public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) { + super.setAndroidEnvironment(rClass, androidSystemServices, androidManifest); + annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); + + validatorHelper.extendsFragment(element, valid); + + validatorHelper.isNotPrivate(element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, HasViewChanged holder) { + + TypeMirror elementType = element.asType(); + String typeQualifiedName = elementType.toString(); + TypeMirror nativeFragmentType = annotationHelper.typeElementFromQualifiedName(CanonicalNameConstants.FRAGMENT).asType(); + boolean isNativeFragment = annotationHelper.isSubtype(elementType, nativeFragmentType); + + JMethod findFragmentByTag; + if (isNativeFragment) { + findFragmentByTag = holder.getFindNativeFragmentByTag(); + } else { + findFragmentByTag = holder.getFindSupportFragmentByTag(); + } + + String fieldName = element.getSimpleName().toString(); + FragmentByTag annotation = element.getAnnotation(FragmentByTag.class); + String tagValue = annotation.value(); + if (tagValue.equals("")) { + tagValue = fieldName; + } + + JBlock methodBody = holder.getOnViewChangedHolder().body(); + methodBody.assign(ref(fieldName), cast(holder.refClass(typeQualifiedName), invoke(findFragmentByTag).arg(lit(tagValue)))); + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/FindFragmentHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/FindFragmentHelper.java index d1d5fb50e8..9c31e4b806 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/FindFragmentHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/FindFragmentHelper.java @@ -40,4 +40,34 @@ public static JMethod createFindSupportFragmentById(EComponentHolder holder) { return method; } + + public static JMethod createFindNativeFragmentByTag(EComponentHolder holder) { + JMethod method = holder.getGeneratedClass().method(PRIVATE, holder.classes().FRAGMENT, "findNativeFragmentByTag"); + JVar tagParam = method.param(holder.classes().STRING, "tag"); + + JBlock body = method.body(); + + body._if(holder.getContextRef()._instanceof(holder.classes().ACTIVITY).not())._then()._return(_null()); + + JVar activityVar = body.decl(holder.classes().ACTIVITY, "activity_", cast(holder.classes().ACTIVITY, holder.getContextRef())); + + body._return(activityVar.invoke("getFragmentManager").invoke("findFragmentByTag").arg(tagParam)); + + return method; + } + + public static JMethod createFindSupportFragmentByTag(EComponentHolder holder) { + JMethod method = holder.getGeneratedClass().method(PRIVATE, holder.classes().SUPPORT_V4_FRAGMENT, "findSupportFragmentByTag"); + JVar tagParam = method.param(holder.classes().STRING, "tag"); + + JBlock body = method.body(); + + body._if(holder.getContextRef()._instanceof(holder.classes().FRAGMENT_ACTIVITY).not())._then()._return(_null()); + + JVar activityVar = body.decl(holder.classes().FRAGMENT_ACTIVITY, "activity_", cast(holder.classes().FRAGMENT_ACTIVITY, holder.getContextRef())); + + body._return(activityVar.invoke("getSupportFragmentManager").invoke("findFragmentByTag").arg(tagParam)); + + return method; + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java index 9c3f608228..f580cd8c7b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java @@ -30,6 +30,8 @@ public class EActivityHolder extends EComponentHolder implements HasIntentBuilde private ViewChangedHolder viewChangedHolder; private JMethod findNativeFragmentById; private JMethod findSupportFragmentById; + private JMethod findNativeFragmentByTag; + private JMethod findSupportFragmentByTag; private RoboGuiceHolder roboGuiceHolder; public EActivityHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { @@ -209,6 +211,38 @@ private void setFindSupportFragmentById() { findSupportFragmentById = method; } + @Override + public JMethod getFindNativeFragmentByTag() { + if (findNativeFragmentByTag == null) { + setFindNativeFragmentByTag(); + } + return findNativeFragmentByTag; + } + + private void setFindNativeFragmentByTag() { + JMethod method = generatedClass.method(PRIVATE, classes().FRAGMENT, "findNativeFragmentByTag"); + JVar tagParam = method.param(classes().STRING, "tag"); + JBlock body = method.body(); + body._return(invoke("getFragmentManager").invoke("findFragmentByTag").arg(tagParam)); + findNativeFragmentByTag = method; + } + + @Override + public JMethod getFindSupportFragmentByTag() { + if (findSupportFragmentByTag == null) { + setFindSupportFragmentByTag(); + } + return findSupportFragmentByTag; + } + + private void setFindSupportFragmentByTag() { + JMethod method = generatedClass.method(PRIVATE, classes().SUPPORT_V4_FRAGMENT, "findSupportFragmentByTag"); + JVar tagParam = method.param(classes().STRING, "tag"); + JBlock body = method.body(); + body._return(invoke("getSupportFragmentManager").invoke("findFragmentByTag").arg(tagParam)); + findSupportFragmentByTag = method; + } + public JMethod getSetContentViewLayout() { if (setContentViewLayout == null) { setSetContentView(); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java index a0802e11af..df8f4ac854 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java @@ -28,6 +28,8 @@ public class EBeanHolder extends EComponentHolder implements HasViewChanged { private JMethod constructor; private JMethod findNativeFragmentById; private JMethod findSupportFragmentById; + private JMethod findNativeFragmentByTag; + private JMethod findSupportFragmentByTag; public EBeanHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); @@ -135,4 +137,28 @@ public JMethod getFindSupportFragmentById() { private void setFindSupportFragmentById() { findSupportFragmentById = FindFragmentHelper.createFindSupportFragmentById(this); } + + @Override + public JMethod getFindNativeFragmentByTag() { + if (findNativeFragmentByTag == null) { + setFindNativeFragmentByTag(); + } + return findNativeFragmentByTag; + } + + private void setFindNativeFragmentByTag() { + findNativeFragmentByTag = FindFragmentHelper.createFindNativeFragmentByTag(this); + } + + @Override + public JMethod getFindSupportFragmentByTag() { + if (findSupportFragmentByTag == null) { + setFindSupportFragmentByTag(); + } + return findSupportFragmentByTag; + } + + private void setFindSupportFragmentByTag() { + findSupportFragmentByTag = FindFragmentHelper.createFindSupportFragmentByTag(this); + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java index 9f61d6b1a4..6680b05615 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java @@ -23,6 +23,8 @@ public class EFragmentHolder extends EComponentHolder implements HasViewChanged private ViewChangedHolder viewChangedHolder; private JMethod findNativeFragmentById; private JMethod findSupportFragmentById; + private JMethod findNativeFragmentByTag; + private JMethod findSupportFragmentByTag; public EFragmentHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); @@ -155,6 +157,30 @@ private void setFindSupportFragmentById() { findSupportFragmentById = FindFragmentHelper.createFindSupportFragmentById(this); } + @Override + public JMethod getFindNativeFragmentByTag() { + if (findNativeFragmentByTag == null) { + setFindNativeFragmentByTag(); + } + return findNativeFragmentByTag; + } + + private void setFindNativeFragmentByTag() { + findNativeFragmentByTag = FindFragmentHelper.createFindNativeFragmentByTag(this); + } + + @Override + public JMethod getFindSupportFragmentByTag() { + if (findSupportFragmentByTag == null) { + setFindSupportFragmentByTag(); + } + return findSupportFragmentByTag; + } + + private void setFindSupportFragmentByTag() { + findSupportFragmentByTag = FindFragmentHelper.createFindSupportFragmentByTag(this); + } + private void setOnCreateView() { JMethod onCreateView = generatedClass.method(PUBLIC, classes().VIEW, "onCreateView"); onCreateView.annotate(Override.class); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java index 804b5f056f..7c17fba59e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java @@ -36,6 +36,8 @@ public class EViewHolder extends EComponentHolder implements HasViewChanged { private ViewChangedHolder viewChangedHolder; private JMethod findNativeFragmentById; private JMethod findSupportFragmentById; + private JMethod findNativeFragmentByTag; + private JMethod findSupportFragmentByTag; public EViewHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); @@ -174,4 +176,28 @@ public JMethod getFindSupportFragmentById() { private void setFindSupportFragmentById() { findSupportFragmentById = FindFragmentHelper.createFindSupportFragmentById(this); } + + @Override + public JMethod getFindNativeFragmentByTag() { + if (findNativeFragmentByTag == null) { + setFindNativeFragmentByTag(); + } + return findNativeFragmentByTag; + } + + private void setFindNativeFragmentByTag() { + findNativeFragmentByTag = FindFragmentHelper.createFindNativeFragmentByTag(this); + } + + @Override + public JMethod getFindSupportFragmentByTag() { + if (findSupportFragmentByTag == null) { + setFindSupportFragmentByTag(); + } + return findSupportFragmentByTag; + } + + private void setFindSupportFragmentByTag() { + findSupportFragmentByTag = FindFragmentHelper.createFindSupportFragmentByTag(this); + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasViewChanged.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasViewChanged.java index d71df1a0bd..ae18c1153c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasViewChanged.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasViewChanged.java @@ -6,4 +6,6 @@ public interface HasViewChanged extends GeneratedClassHolder { ViewChangedHolder getOnViewChangedHolder(); JMethod getFindNativeFragmentById(); JMethod getFindSupportFragmentById(); + JMethod getFindNativeFragmentByTag(); + JMethod getFindSupportFragmentByTag(); } From d7126a31fc9bc1acf94e8589ae73168633ce048d Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 30 May 2013 11:59:22 +0200 Subject: [PATCH 18/86] Implement FromHtmlHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/FromHtmlHandler.java | 65 +++++++++++++++++++ .../holder/HasViewChanged.java | 2 + 3 files changed, 68 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index c77753939f..880c178322 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -33,6 +33,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new ViewByIdHandler(processingEnvironment)); add(new FragmentByIdHandler(processingEnvironment)); add(new FragmentByTagHandler(processingEnvironment)); + add(new FromHtmlHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java new file mode 100644 index 0000000000..53ff18b706 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java @@ -0,0 +1,65 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JFieldRef; +import org.androidannotations.annotations.FromHtml; +import org.androidannotations.helper.AndroidManifest; +import org.androidannotations.helper.IdAnnotationHelper; +import org.androidannotations.helper.IdValidatorHelper; +import org.androidannotations.holder.HasViewChanged; +import org.androidannotations.model.AndroidSystemServices; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.ProcessHolder; +import org.androidannotations.rclass.IRClass; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + +import static com.sun.codemodel.JExpr._null; +import static com.sun.codemodel.JExpr.ref; + +public class FromHtmlHandler extends BaseAnnotationHandler { + + private IdAnnotationHelper annotationHelper; + + public FromHtmlHandler(ProcessingEnvironment processingEnvironment) { + super(FromHtml.class, processingEnvironment); + } + + @Override + public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) { + super.setAndroidEnvironment(rClass, androidSystemServices, androidManifest); + annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); + + validatorHelper.hasViewByIdAnnotation(element, validatedElements, valid); + + validatorHelper.extendsTextView(element, valid); + + validatorHelper.resIdsExist(element, IRClass.Res.STRING, IdValidatorHelper.FallbackStrategy.USE_ELEMENT_NAME, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, HasViewChanged holder) { + ProcessHolder.Classes classes = holder.classes(); + + String fieldName = element.getSimpleName().toString(); + + JFieldRef idRef = annotationHelper.extractOneAnnotationFieldRef(holder, element, IRClass.Res.STRING, true); + + JBlock methodBody = holder.getOnViewChangedHolder().body(); + methodBody // + ._if(ref(fieldName).ne(_null())) // + ._then() // + .invoke(ref(fieldName), "setText").arg(classes.HTML.staticInvoke("fromHtml").arg(holder.getContextRef().invoke("getString").arg(idRef))); + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasViewChanged.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasViewChanged.java index ae18c1153c..a22497a339 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasViewChanged.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasViewChanged.java @@ -1,5 +1,6 @@ package org.androidannotations.holder; +import com.sun.codemodel.JExpression; import com.sun.codemodel.JMethod; public interface HasViewChanged extends GeneratedClassHolder { @@ -8,4 +9,5 @@ public interface HasViewChanged extends GeneratedClassHolder { JMethod getFindSupportFragmentById(); JMethod getFindNativeFragmentByTag(); JMethod getFindSupportFragmentByTag(); + JExpression getContextRef(); } From 6e7d28a5e8190bd37e2a9fdc6e8153d212bec149 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 30 May 2013 14:01:11 +0200 Subject: [PATCH 19/86] Implement ClickHandler --- .../handler/AbstractListenerHandler.java | 120 ++++++++++++++++++ .../handler/AnnotationHandlers.java | 1 + .../handler/ClickHandler.java | 69 ++++++++++ .../helper/IdAnnotationHelper.java | 7 +- 4 files changed, 196 insertions(+), 1 deletion(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ClickHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java new file mode 100644 index 0000000000..aa9796325f --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java @@ -0,0 +1,120 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.helper.AndroidManifest; +import org.androidannotations.helper.IdAnnotationHelper; +import org.androidannotations.helper.IdValidatorHelper; +import org.androidannotations.holder.HasViewChanged; +import org.androidannotations.holder.ViewChangedHolder; +import org.androidannotations.model.AndroidSystemServices; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.ProcessHolder; +import org.androidannotations.rclass.IRClass; +import org.androidannotations.validation.IsValid; + +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 java.util.List; + +import static com.sun.codemodel.JExpr.*; + +public abstract class AbstractListenerHandler extends BaseAnnotationHandler { + + private IdAnnotationHelper helper; + private HasViewChanged holder; + + public AbstractListenerHandler(Class targetClass, ProcessingEnvironment processingEnvironment) { + super(targetClass, processingEnvironment); + } + + public AbstractListenerHandler(String target, ProcessingEnvironment processingEnvironment) { + super(target, processingEnvironment); + } + + @Override + public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) { + super.setAndroidEnvironment(rClass, androidSystemServices, androidManifest); + helper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); + + validatorHelper.resIdsExist(element, IRClass.Res.ID, IdValidatorHelper.FallbackStrategy.USE_ELEMENT_NAME, valid); + + validatorHelper.isNotPrivate(element, valid); + + validatorHelper.doesntThrowException(element, valid); + + validatorHelper.uniqueId(element, validatedElements, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, HasViewChanged holder) { + 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, IRClass.Res.ID, true); + + JDefinedClass listenerAnonymousClass = holder.codeModel().anonymousClass(getListenerClass()); + JMethod listenerMethod = createListenerMethod(listenerAnonymousClass); + listenerMethod.annotate(Override.class); + + JBlock listenerMethodBody = listenerMethod.body(); + + JExpression activityRef = holder.getGeneratedClass().staticRef("this"); + JInvocation call = invoke(activityRef, methodName); + + makeCall(listenerMethodBody, call, returnType); + + processParameters(listenerMethod, call, parameters); + + for (JFieldRef idRef : idsRefs) { + ViewChangedHolder onViewChanged = holder.getOnViewChangedHolder(); + JBlock block = onViewChanged.body().block(); + + JExpression findViewExpression = onViewChanged.findViewById(idRef); + if (!getViewClass().equals(classes().VIEW)) { + findViewExpression = cast(getViewClass(), findViewExpression); + } + + JVar view = block.decl(getViewClass(), "view", findViewExpression); + 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(); + + protected JType getViewClass() { + return classes().VIEW; + } + + protected ProcessHolder.Classes classes() { + return holder.classes(); + } + + protected JCodeModel codeModel() { + return holder.codeModel(); + } +} \ No newline at end of file diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 880c178322..a1afd56e7a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -34,6 +34,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new FragmentByIdHandler(processingEnvironment)); add(new FragmentByTagHandler(processingEnvironment)); add(new FromHtmlHandler(processingEnvironment)); + add(new ClickHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ClickHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ClickHandler.java new file mode 100644 index 0000000000..90005f77f8 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ClickHandler.java @@ -0,0 +1,69 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.Click; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +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 java.util.List; + +public class ClickHandler extends AbstractListenerHandler { + + public ClickHandler(ProcessingEnvironment processingEnvironment) { + super(Click.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + if (!super.validate(element, validatedElements)) { + valid.invalidate(); + } + + ExecutableElement executableElement = (ExecutableElement) element; + + validatorHelper.returnTypeIsVoid(executableElement, valid); + + validatorHelper.param.zeroOrOneViewParameter(executableElement, valid); + + return valid.isValid(); + } + + @Override + protected void makeCall(JBlock listenerMethodBody, JInvocation call, TypeMirror returnType) { + listenerMethodBody.add(call); + } + + @Override + protected void processParameters(JMethod listenerMethod, JInvocation call, List parameters) { + boolean hasItemParameter = parameters.size() == 1; + + JVar viewParam = listenerMethod.param(classes().VIEW, "view"); + + if (hasItemParameter) { + call.arg(viewParam); + } + } + + @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/helper/IdAnnotationHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdAnnotationHelper.java index 32d2fec85a..a26f4038fc 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdAnnotationHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdAnnotationHelper.java @@ -49,7 +49,12 @@ public List extractAnnotationResources(Element element, Res res, boolean return super.extractAnnotationResources(element, getTarget(), rClass.get(res), useElementName); } - public List extractAnnotationFieldRefs(EBeanHolder holder, Element element, Res res, boolean useElementName) { + public List extractAnnotationFieldRefs(GeneratedClassHolder holder, Element element, Res res, boolean useElementName) { + return super.extractAnnotationFieldRefs(holder, element, getTarget(), rClass.get(res), useElementName); + } + + + public List extractAnnotationFieldRefs(EBeanHolder holder, Element element, Res res, boolean useElementName) { return super.extractAnnotationFieldRefs(holder, element, getTarget(), rClass.get(res), useElementName); } From 9d0a9ebeb4e2061d20fc9a9ada9ec19d2893b1aa Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 30 May 2013 14:27:11 +0200 Subject: [PATCH 20/86] Implement LongClickHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/LongClickHandler.java | 73 +++++++++++++++++++ 2 files changed, 74 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/LongClickHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index a1afd56e7a..d663839190 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -35,6 +35,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new FragmentByTagHandler(processingEnvironment)); add(new FromHtmlHandler(processingEnvironment)); add(new ClickHandler(processingEnvironment)); + add(new LongClickHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/LongClickHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/LongClickHandler.java new file mode 100644 index 0000000000..67b045685a --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/LongClickHandler.java @@ -0,0 +1,73 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.LongClick; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +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 java.util.List; + +public class LongClickHandler extends AbstractListenerHandler { + + public LongClickHandler(ProcessingEnvironment processingEnvironment) { + super(LongClick.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + if (!super.validate(element, validatedElements)) { + valid.invalidate(); + } + + ExecutableElement executableElement = (ExecutableElement) element; + + validatorHelper.returnTypeIsVoidOrBoolean(executableElement, valid); + + validatorHelper.param.zeroOrOneViewParameter(executableElement, valid); + + return valid.isValid(); + } + + @Override + protected void makeCall(JBlock listenerMethodBody, JInvocation call, TypeMirror returnType) { + boolean returnMethodResult = returnType.getKind() != TypeKind.VOID; + if (returnMethodResult) { + listenerMethodBody._return(call); + } else { + listenerMethodBody.add(call); + listenerMethodBody._return(JExpr.TRUE); + } + } + + @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"); + } + + @Override + protected String getSetterName() { + return "setOnLongClickListener"; + } + + @Override + protected JClass getListenerClass() { + return classes().VIEW_ON_LONG_CLICK_LISTENER; + } +} From 3f0f7e1fb58d5cab54a6d96f4872abf6e39e648d Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 30 May 2013 14:50:51 +0200 Subject: [PATCH 21/86] Implement TouchHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/TouchHandler.java | 77 +++++++++++++++++++ 2 files changed, 78 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TouchHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index d663839190..8ba1af9ec6 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -36,6 +36,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new FromHtmlHandler(processingEnvironment)); add(new ClickHandler(processingEnvironment)); add(new LongClickHandler(processingEnvironment)); + add(new TouchHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TouchHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TouchHandler.java new file mode 100644 index 0000000000..94354791f6 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TouchHandler.java @@ -0,0 +1,77 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.Touch; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +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 java.util.List; + +public class TouchHandler extends AbstractListenerHandler { + + public TouchHandler(ProcessingEnvironment processingEnvironment) { + super(Touch.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + if (!super.validate(element, validatedElements)) { + valid.invalidate(); + } + + ExecutableElement executableElement = (ExecutableElement) element; + + validatorHelper.returnTypeIsVoidOrBoolean(executableElement, valid); + + validatorHelper.param.hasOneMotionEventOrTwoMotionEventViewParameters(executableElement, valid); + + return valid.isValid(); + } + + @Override + protected void makeCall(JBlock listenerMethodBody, JInvocation call, TypeMirror returnType) { + boolean returnMethodResult = returnType.getKind() != TypeKind.VOID; + + if (returnMethodResult) { + listenerMethodBody._return(call); + } else { + listenerMethodBody.add(call); + listenerMethodBody._return(JExpr.TRUE); + } + } + + @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); + } + } + + @Override + protected JMethod createListenerMethod(JDefinedClass listenerAnonymousClass) { + return listenerAnonymousClass.method(JMod.PUBLIC, codeModel().BOOLEAN, "onTouch"); + } + + @Override + protected String getSetterName() { + return "setOnTouchListener"; + } + + @Override + protected JClass getListenerClass() { + return classes().VIEW_ON_TOUCH_LISTENER; + } +} From 7fd8a681ec34f6b2ff4a14c5af38f78c4fafab95 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 30 May 2013 16:44:18 +0200 Subject: [PATCH 22/86] Implement FocusChangeHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/FocusChangeHandler.java | 71 +++++++++++++++++++ 2 files changed, 72 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FocusChangeHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 8ba1af9ec6..83d3b3c484 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -37,6 +37,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new ClickHandler(processingEnvironment)); add(new LongClickHandler(processingEnvironment)); add(new TouchHandler(processingEnvironment)); + add(new FocusChangeHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FocusChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FocusChangeHandler.java new file mode 100644 index 0000000000..ee0e068a2e --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FocusChangeHandler.java @@ -0,0 +1,71 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.FocusChange; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +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 java.util.List; + +public class FocusChangeHandler extends AbstractListenerHandler { + + public FocusChangeHandler(ProcessingEnvironment processingEnvironment) { + super(FocusChange.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + if (!super.validate(element, validatedElements)) { + valid.invalidate(); + } + + ExecutableElement executableElement = (ExecutableElement) element; + validatorHelper.returnTypeIsVoid(executableElement, valid); + + validatorHelper.param.hasZeroOrOneViewOrTwoViewBooleanParameters(executableElement, valid); + + return valid.isValid(); + } + + @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; + } +} From c3f8031e0ab46587f2803884cbc974213ff0c841 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 30 May 2013 16:55:02 +0200 Subject: [PATCH 23/86] Implement CheckedChangeHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/CheckedChangeHandler.java | 76 +++++++++++++++++++ .../helper/CanonicalNameConstants.java | 1 + .../process/ProcessHolder.java | 1 + 4 files changed, 79 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CheckedChangeHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 83d3b3c484..a6fdeeb4af 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -38,6 +38,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new LongClickHandler(processingEnvironment)); add(new TouchHandler(processingEnvironment)); add(new FocusChangeHandler(processingEnvironment)); + add(new CheckedChangeHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CheckedChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CheckedChangeHandler.java new file mode 100644 index 0000000000..63e3d0ff2e --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CheckedChangeHandler.java @@ -0,0 +1,76 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.CheckedChange; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +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 java.util.List; + +public class CheckedChangeHandler extends AbstractListenerHandler { + + public CheckedChangeHandler(ProcessingEnvironment processingEnvironment) { + super(CheckedChange.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + if (!super.validate(element, validatedElements)) { + valid.invalidate(); + } + + ExecutableElement executableElement = (ExecutableElement) element; + validatorHelper.returnTypeIsVoid(executableElement, valid); + + validatorHelper.param.hasZeroOrOneCompoundButtonOrTwoCompoundButtonBooleanParameters(executableElement, valid); + + return valid.isValid(); + } + + @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 classes().COMPOUND_BUTTON_ON_CHECKED_CHANGE_LISTENER; + } + + @Override + protected JType getViewClass() { + return classes().COMPOUND_BUTTON; + } +} 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 587607d52f..2f51eb4b53 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/CanonicalNameConstants.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/CanonicalNameConstants.java @@ -61,6 +61,7 @@ public final class CanonicalNameConstants { 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 COMPOUND_BUTTON_ON_CHECKED_CHANGE_LISTENER = "android.widget.CompoundButton.OnCheckedChangeListener"; 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/process/ProcessHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ProcessHolder.java index abbe15dfa6..6cd176dfac 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ProcessHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ProcessHolder.java @@ -64,6 +64,7 @@ public class Classes { 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 COMPOUND_BUTTON_ON_CHECKED_CHANGE_LISTENER = refClass(CanonicalNameConstants.COMPOUND_BUTTON_ON_CHECKED_CHANGE_LISTENER); 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); From 90f9474174e4b35255c9b3b120d86ea80db38f1a Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 30 May 2013 17:20:11 +0200 Subject: [PATCH 24/86] Implement ItemClickHandler --- .../handler/AbstractListenerHandler.java | 4 + .../handler/AnnotationHandlers.java | 1 + .../handler/ItemClickHandler.java | 89 +++++++++++++++++++ 3 files changed, 94 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemClickHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java index aa9796325f..2f8312dc18 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java @@ -117,4 +117,8 @@ protected ProcessHolder.Classes classes() { protected JCodeModel codeModel() { return holder.codeModel(); } + + protected JClass refClass(String qualifiedClassName) { + return holder.refClass(qualifiedClassName); + } } \ No newline at end of file diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index a6fdeeb4af..1cbacb474d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -39,6 +39,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new TouchHandler(processingEnvironment)); add(new FocusChangeHandler(processingEnvironment)); add(new CheckedChangeHandler(processingEnvironment)); + add(new ItemClickHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemClickHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemClickHandler.java new file mode 100644 index 0000000000..26c21c04c1 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemClickHandler.java @@ -0,0 +1,89 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.ItemClick; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +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 java.util.List; + +import static com.sun.codemodel.JExpr.cast; +import static com.sun.codemodel.JExpr.invoke; + +public class ItemClickHandler extends AbstractListenerHandler { + + public ItemClickHandler(ProcessingEnvironment processingEnvironment) { + super(ItemClick.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + if (!super.validate(element, validatedElements)) { + valid.invalidate(); + } + + ExecutableElement executableElement = (ExecutableElement) element; + + validatorHelper.returnTypeIsVoid(executableElement, valid); + + validatorHelper.param.zeroOrOneParameter(executableElement, valid); + + return valid.isValid(); + } + + @Override + protected void makeCall(JBlock listenerMethodBody, JInvocation call, TypeMirror returnType) { + listenerMethodBody.add(call); + } + + @Override + protected void processParameters(JMethod listenerMethod, JInvocation call, List parameters) { + boolean hasItemParameter = parameters.size() == 1; + + JClass narrowAdapterViewClass = classes().ADAPTER_VIEW.narrow(codeModel().wildcard()); + JVar onItemClickParentParam = listenerMethod.param(narrowAdapterViewClass, "parent"); + listenerMethod.param(classes().VIEW, "view"); + JVar onItemClickPositionParam = listenerMethod.param(codeModel().INT, "position"); + listenerMethod.param(codeModel().LONG, "id"); + + if (hasItemParameter) { + VariableElement parameter = parameters.get(0); + + TypeMirror parameterType = parameter.asType(); + if (parameterType.getKind() == TypeKind.INT) { + call.arg(onItemClickPositionParam); + } else { + String parameterTypeQualifiedName = parameterType.toString(); + call.arg(cast(refClass(parameterTypeQualifiedName), invoke(onItemClickParentParam, "getAdapter").invoke("getItem").arg(onItemClickPositionParam))); + } + } + } + + @Override + protected JMethod createListenerMethod(JDefinedClass listenerAnonymousClass) { + return listenerAnonymousClass.method(JMod.PUBLIC, codeModel().VOID, "onItemClick"); + } + + @Override + protected String getSetterName() { + return "setOnItemClickListener"; + } + + @Override + protected JClass getListenerClass() { + return classes().ON_ITEM_CLICK_LISTENER; + } + + @Override + protected JType getViewClass() { + return classes().ADAPTER_VIEW.narrow(codeModel().wildcard()); + } +} From 0ff7b93fba3b1b51bf39e2251ffa26e5e492b58f Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 30 May 2013 17:41:07 +0200 Subject: [PATCH 25/86] Implement ItemSelectHandler --- .../handler/AbstractListenerHandler.java | 7 +- .../handler/AnnotationHandlers.java | 1 + .../handler/ItemSelectHandler.java | 112 ++++++++++++++++++ 3 files changed, 119 insertions(+), 1 deletion(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemSelectHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java index 2f8312dc18..60488de75a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java @@ -25,6 +25,7 @@ public abstract class AbstractListenerHandler extends BaseAnnotationHandler targetClass, ProcessingEnvironment processingEnvironment) { super(targetClass, processingEnvironment); @@ -61,7 +62,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { public void process(Element element, HasViewChanged holder) { this.holder = holder; - String methodName = element.getSimpleName().toString(); + this.methodName = element.getSimpleName().toString(); ExecutableElement executableElement = (ExecutableElement) element; List parameters = executableElement.getParameters(); @@ -121,4 +122,8 @@ protected JCodeModel codeModel() { protected JClass refClass(String qualifiedClassName) { return holder.refClass(qualifiedClassName); } + + protected String getMethodName() { + return methodName; + } } \ No newline at end of file diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 1cbacb474d..32100e4423 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -40,6 +40,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new FocusChangeHandler(processingEnvironment)); add(new CheckedChangeHandler(processingEnvironment)); add(new ItemClickHandler(processingEnvironment)); + add(new ItemSelectHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemSelectHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemSelectHandler.java new file mode 100644 index 0000000000..342fec7485 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemSelectHandler.java @@ -0,0 +1,112 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.ItemSelect; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +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 java.util.List; + +import static com.sun.codemodel.JExpr._null; +import static com.sun.codemodel.JExpr.invoke; +import static com.sun.codemodel.JExpr.lit; + +public class ItemSelectHandler extends AbstractListenerHandler { + + private JMethod onNothingSelectedMethod; + + public ItemSelectHandler(ProcessingEnvironment processingEnvironment) { + super(ItemSelect.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + if (!super.validate(element, validatedElements)) { + valid.invalidate(); + } + + ExecutableElement executableElement = (ExecutableElement) element; + + validatorHelper.returnTypeIsVoid(executableElement, valid); + + validatorHelper.param.hasOneOrTwoParametersAndFirstIsBoolean(executableElement, valid); + + return valid.isValid(); + } + + @Override + protected void makeCall(JBlock listenerMethodBody, JInvocation call, TypeMirror returnType) { + listenerMethodBody.add(call); + } + + @Override + protected void processParameters(JMethod listenerMethod, JInvocation itemSelectedCall, List parameters) { + JClass narrowAdapterViewClass = classes().ADAPTER_VIEW.narrow(codeModel().wildcard()); + JVar onItemClickParentParam = listenerMethod.param(narrowAdapterViewClass, "parent"); + listenerMethod.param(classes().VIEW, "view"); + JVar onItemClickPositionParam = listenerMethod.param(codeModel().INT, "position"); + listenerMethod.param(codeModel().LONG, "id"); + + itemSelectedCall.arg(JExpr.TRUE); + boolean hasItemParameter = parameters.size() == 2; + boolean secondParameterIsInt = false; + String secondParameterQualifiedName = null; + if (hasItemParameter) { + VariableElement secondParameter = parameters.get(1); + TypeMirror secondParameterType = secondParameter.asType(); + secondParameterQualifiedName = secondParameterType.toString(); + secondParameterIsInt = secondParameterType.getKind() == TypeKind.INT; + } + + if (hasItemParameter) { + + if (secondParameterIsInt) { + itemSelectedCall.arg(onItemClickPositionParam); + } else { + itemSelectedCall.arg(JExpr.cast(refClass(secondParameterQualifiedName), invoke(onItemClickParentParam, "getAdapter").invoke("getItem").arg(onItemClickPositionParam))); + } + } + + onNothingSelectedMethod.param(narrowAdapterViewClass, "parent"); + JInvocation nothingSelectedCall = onNothingSelectedMethod.body().invoke(getMethodName()); + nothingSelectedCall.arg(JExpr.FALSE); + if (hasItemParameter) { + if (secondParameterIsInt) { + nothingSelectedCall.arg(lit(-1)); + } else { + nothingSelectedCall.arg(_null()); + } + } + } + + @Override + protected JMethod createListenerMethod(JDefinedClass listenerAnonymousClass) { + onNothingSelectedMethod = listenerAnonymousClass.method(JMod.PUBLIC, codeModel().VOID, "onNothingSelected"); + onNothingSelectedMethod.annotate(Override.class); + return listenerAnonymousClass.method(JMod.PUBLIC, codeModel().VOID, "onItemSelected"); + } + + @Override + protected String getSetterName() { + return "setOnItemSelectedListener"; + } + + @Override + protected JClass getListenerClass() { + return classes().ON_ITEM_SELECTED_LISTENER; + } + + @Override + protected JType getViewClass() { + return classes().ADAPTER_VIEW.narrow(codeModel().wildcard()); + } + +} From a37c6b248c8582ed6ff2a3232421cffb801e582f Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 30 May 2013 17:50:27 +0200 Subject: [PATCH 26/86] Implement ItemLongClickHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/ItemLongClickHandler.java | 95 +++++++++++++++++++ 2 files changed, 96 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemLongClickHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 32100e4423..11d20f8fac 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -41,6 +41,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new CheckedChangeHandler(processingEnvironment)); add(new ItemClickHandler(processingEnvironment)); add(new ItemSelectHandler(processingEnvironment)); + add(new ItemLongClickHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemLongClickHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemLongClickHandler.java new file mode 100644 index 0000000000..6c91e85729 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemLongClickHandler.java @@ -0,0 +1,95 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.ItemLongClick; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +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 java.util.List; + +import static com.sun.codemodel.JExpr.cast; +import static com.sun.codemodel.JExpr.invoke; + +public class ItemLongClickHandler extends AbstractListenerHandler { + + public ItemLongClickHandler(ProcessingEnvironment processingEnvironment) { + super(ItemLongClick.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + if (!super.validate(element, validatedElements)) { + valid.invalidate(); + } + + ExecutableElement executableElement = (ExecutableElement) element; + + validatorHelper.returnTypeIsVoidOrBoolean(executableElement, valid); + + validatorHelper.param.zeroOrOneParameter(executableElement, valid); + + return valid.isValid(); + } + + @Override + protected void makeCall(JBlock listenerMethodBody, JInvocation call, TypeMirror returnType) { + boolean returnMethodResult = returnType.getKind() != TypeKind.VOID; + if (returnMethodResult) { + listenerMethodBody._return(call); + } else { + listenerMethodBody.add(call); + listenerMethodBody._return(JExpr.TRUE); + } + } + + @Override + protected void processParameters(JMethod listenerMethod, JInvocation call, List parameters) { + boolean hasItemParameter = parameters.size() == 1; + + JClass narrowAdapterViewClass = classes().ADAPTER_VIEW.narrow(codeModel().wildcard()); + JVar onItemClickParentParam = listenerMethod.param(narrowAdapterViewClass, "parent"); + listenerMethod.param(classes().VIEW, "view"); + JVar onItemClickPositionParam = listenerMethod.param(codeModel().INT, "position"); + listenerMethod.param(codeModel().LONG, "id"); + + if (hasItemParameter) { + VariableElement parameter = parameters.get(0); + + TypeMirror parameterType = parameter.asType(); + if (parameterType.getKind() == TypeKind.INT) { + call.arg(onItemClickPositionParam); + } else { + String parameterTypeQualifiedName = parameterType.toString(); + call.arg(cast(refClass(parameterTypeQualifiedName), invoke(onItemClickParentParam, "getAdapter").invoke("getItem").arg(onItemClickPositionParam))); + } + } + } + + @Override + protected JMethod createListenerMethod(JDefinedClass listenerAnonymousClass) { + return listenerAnonymousClass.method(JMod.PUBLIC, codeModel().BOOLEAN, "onItemLongClick"); + } + + @Override + protected String getSetterName() { + return "setOnItemLongClickListener"; + } + + @Override + protected JClass getListenerClass() { + return classes().ON_ITEM_LONG_CLICK_LISTENER; + } + + @Override + protected JType getViewClass() { + return classes().ADAPTER_VIEW.narrow(codeModel().wildcard()); + } +} From 29c0e845eec07d4475f5d88dc7d9edc871225141 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Fri, 31 May 2013 09:20:28 +0200 Subject: [PATCH 27/86] Implement ResHandler --- .../handler/AnnotationHandlers.java | 4 + .../handler/ResHandler.java | 88 +++++++++++++++++++ .../holder/EComponentHolder.java | 12 +++ .../androidannotations/model/AndroidRes.java | 29 ++---- 4 files changed, 112 insertions(+), 21 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 11d20f8fac..355721d46f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -2,6 +2,7 @@ import org.androidannotations.helper.AndroidManifest; import org.androidannotations.holder.GeneratedClassHolder; +import org.androidannotations.model.AndroidRes; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; import org.androidannotations.rclass.IRClass; @@ -42,6 +43,9 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new ItemClickHandler(processingEnvironment)); add(new ItemSelectHandler(processingEnvironment)); add(new ItemLongClickHandler(processingEnvironment)); + for (AndroidRes androidRes : AndroidRes.values()) { + add(new ResHandler(androidRes, processingEnvironment)); + } add(new AfterInjectHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java new file mode 100644 index 0000000000..07e626c0b3 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java @@ -0,0 +1,88 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JFieldRef; +import org.androidannotations.annotations.res.HtmlRes; +import org.androidannotations.helper.AndroidManifest; +import org.androidannotations.helper.CanonicalNameConstants; +import org.androidannotations.helper.IdAnnotationHelper; +import org.androidannotations.helper.IdValidatorHelper; +import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.model.AndroidRes; +import org.androidannotations.model.AndroidSystemServices; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.ProcessHolder; +import org.androidannotations.rclass.IRClass; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.type.TypeMirror; +import javax.swing.text.html.HTML; + +import static com.sun.codemodel.JExpr.invoke; +import static com.sun.codemodel.JExpr.ref; + +public class ResHandler extends BaseAnnotationHandler { + + private AndroidRes androidRes; + private IdAnnotationHelper annotationHelper; + + public ResHandler(AndroidRes androidRes, ProcessingEnvironment processingEnvironment) { + super(androidRes.getAnnotationClass(), processingEnvironment); + this.androidRes = androidRes; + } + + @Override + public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) { + super.setAndroidEnvironment(rClass, androidSystemServices, androidManifest); + annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); + + TypeMirror fieldTypeMirror = element.asType(); + + validatorHelper.allowedType(element, valid, fieldTypeMirror, androidRes.getAllowedTypes()); + + validatorHelper.resIdsExist(element, androidRes.getRInnerClass(), IdValidatorHelper.FallbackStrategy.USE_ELEMENT_NAME, valid); + + validatorHelper.isNotPrivate(element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EComponentHolder holder) { + ProcessHolder.Classes classes = holder.classes(); + + String fieldName = element.getSimpleName().toString(); + + IRClass.Res resInnerClass = androidRes.getRInnerClass(); + + JFieldRef idRef = annotationHelper.extractOneAnnotationFieldRef(holder, element, resInnerClass, true); + + JBlock methodBody = holder.getInit().body(); + + TypeMirror fieldTypeMirror = element.asType(); + String fieldType = fieldTypeMirror.toString(); + + // Special case for loading animations + if (CanonicalNameConstants.ANIMATION.equals(fieldType)) { + methodBody.assign(ref(fieldName), classes.ANIMATION_UTILS.staticInvoke("loadAnimation").arg(holder.getContextRef()).arg(idRef)); + } else { + String resourceMethodName = androidRes.getResourceMethodName(); + + // Special case for @HtmlRes + if (element.getAnnotation(HtmlRes.class) != null) { + methodBody.assign(ref(fieldName), classes.HTML.staticInvoke("fromHtml").arg(invoke(holder.getResourcesRef(), resourceMethodName).arg(idRef))); + } else { + methodBody.assign(ref(fieldName), invoke(holder.getResourcesRef(), resourceMethodName).arg(idRef)); + } + } + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java index 57012d567c..470609077c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java @@ -2,6 +2,7 @@ import com.sun.codemodel.JExpression; import com.sun.codemodel.JMethod; +import com.sun.codemodel.JVar; import org.androidannotations.process.ProcessHolder; import javax.lang.model.element.TypeElement; @@ -11,6 +12,7 @@ public abstract class EComponentHolder extends BaseGeneratedClassHolder { protected JExpression contextRef; protected JMethod init; + private JVar resourcesRef; public EComponentHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); @@ -34,4 +36,14 @@ public JMethod getInit() { protected abstract void setInit(); + public JVar getResourcesRef() { + if (resourcesRef == null) { + setResourcesRef(); + } + return resourcesRef; + } + + private void setResourcesRef() { + resourcesRef = getInit().body().decl(classes().RESOURCES, "resources_", getContextRef().invoke("getResources")); + } } 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 b98f8777b4..5637f24c45 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/AndroidRes.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/AndroidRes.java @@ -15,32 +15,15 @@ */ package org.androidannotations.model; +import org.androidannotations.annotations.res.*; +import org.androidannotations.rclass.IRClass.Res; + +import javax.lang.model.element.Element; import java.lang.annotation.Annotation; import java.lang.reflect.Method; import java.util.Arrays; import java.util.List; -import javax.lang.model.element.Element; - -import org.androidannotations.annotations.res.AnimationRes; -import org.androidannotations.annotations.res.BooleanRes; -import org.androidannotations.annotations.res.ColorRes; -import org.androidannotations.annotations.res.ColorStateListRes; -import org.androidannotations.annotations.res.DimensionPixelOffsetRes; -import org.androidannotations.annotations.res.DimensionPixelSizeRes; -import org.androidannotations.annotations.res.DimensionRes; -import org.androidannotations.annotations.res.DrawableRes; -import org.androidannotations.annotations.res.HtmlRes; -import org.androidannotations.annotations.res.IntArrayRes; -import org.androidannotations.annotations.res.IntegerRes; -import org.androidannotations.annotations.res.LayoutRes; -import org.androidannotations.annotations.res.MovieRes; -import org.androidannotations.annotations.res.StringArrayRes; -import org.androidannotations.annotations.res.StringRes; -import org.androidannotations.annotations.res.TextArrayRes; -import org.androidannotations.annotations.res.TextRes; -import org.androidannotations.rclass.IRClass.Res; - public enum AndroidRes { STRING(Res.STRING, StringRes.class, "getString", "java.lang.String"), // @@ -77,6 +60,10 @@ public Res getRInnerClass() { return rInnerClass; } + public Class getAnnotationClass() { + return annotationClass; + } + public String getTarget() { return annotationClass.getName(); } From 18aaf831954432f3e8cf9c2c5e1253213afbee3a Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Fri, 31 May 2013 09:32:59 +0200 Subject: [PATCH 28/86] Implement TransactionalHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/TransactionalHandler.java | 92 ++++++++++++ .../helper/APTCodeModelHelper.java | 138 +++++++++++++----- 3 files changed, 198 insertions(+), 33 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TransactionalHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 355721d46f..bf0e3c82dd 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -46,6 +46,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { for (AndroidRes androidRes : AndroidRes.values()) { add(new ResHandler(androidRes, processingEnvironment)); } + add(new TransactionalHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TransactionalHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TransactionalHandler.java new file mode 100644 index 0000000000..be3d420b43 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TransactionalHandler.java @@ -0,0 +1,92 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.Transactional; +import org.androidannotations.helper.APTCodeModelHelper; +import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; + +public class TransactionalHandler extends BaseAnnotationHandler { + + private final APTCodeModelHelper codeModelHelper = new APTCodeModelHelper(); + + public TransactionalHandler(ProcessingEnvironment processingEnvironment) { + super(Transactional.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); + + validatorHelper.isNotPrivate(element, valid); + + ExecutableElement executableElement = (ExecutableElement) element; + + validatorHelper.doesntThrowException(executableElement, valid); + + validatorHelper.isNotFinal(element, valid); + + validatorHelper.param.hasOneOrTwoParametersAndFirstIsDb(executableElement, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EComponentHolder holder) { + ExecutableElement executableElement = (ExecutableElement) element; + + String returnTypeName = executableElement.getReturnType().toString(); + JClass returnType = holder.refClass(returnTypeName); + + JMethod method = codeModelHelper.overrideAnnotatedMethod(executableElement, holder); + codeModelHelper.removeBody(method); + + JVar db = method.params().get(0); + + JBlock body = method.body(); + + body.invoke(db, "beginTransaction"); + + JTryBlock tryBlock = body._try(); + + JExpression activitySuper = holder.getGeneratedClass().staticRef("super"); + JInvocation superCall = JExpr.invoke(activitySuper, method); + + for (JVar param : method.params()) { + superCall.arg(param); + } + JBlock tryBody = tryBlock.body(); + if (returnTypeName.equals("void")) { + tryBody.add(superCall); + tryBody.invoke(db, "setTransactionSuccessful"); + tryBody._return(); + } else { + JVar result = tryBody.decl(returnType, "result_", superCall); + tryBody.invoke(db, "setTransactionSuccessful"); + tryBody._return(result); + } + + JCatchBlock catchBlock = tryBlock._catch(holder.refClass(RuntimeException.class)); + + JVar exceptionParam = catchBlock.param("e"); + + JBlock catchBody = catchBlock.body(); + + JInvocation errorInvoke = catchBody.staticInvoke(holder.classes().LOG, "e"); + + errorInvoke.arg(holder.getGeneratedClass().name()); + errorInvoke.arg("Error in transaction"); + errorInvoke.arg(exceptionParam); + + catchBody._throw(exceptionParam); + + tryBlock._finally().invoke(db, "endTransaction"); + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java index 1648c76447..87b880606a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java @@ -15,18 +15,10 @@ */ package org.androidannotations.helper; -import static com.sun.codemodel.JExpr._new; -import static com.sun.codemodel.JExpr._this; -import static com.sun.codemodel.JExpr.cast; -import static com.sun.codemodel.JMod.FINAL; -import static com.sun.codemodel.JMod.PRIVATE; -import static com.sun.codemodel.JMod.PUBLIC; -import static com.sun.codemodel.JMod.STATIC; -import static javax.lang.model.element.ElementKind.CONSTRUCTOR; - -import java.lang.reflect.Field; -import java.util.ArrayList; -import java.util.List; +import com.sun.codemodel.*; +import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.processing.EBeanHolder; +import org.androidannotations.processing.EBeansHolder.Classes; import javax.lang.model.element.Element; import javax.lang.model.element.ExecutableElement; @@ -35,31 +27,57 @@ import javax.lang.model.type.DeclaredType; import javax.lang.model.type.TypeMirror; import javax.lang.model.type.WildcardType; +import java.lang.reflect.Field; +import java.util.ArrayList; +import java.util.List; -import org.androidannotations.processing.EBeanHolder; -import org.androidannotations.processing.EBeansHolder.Classes; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JCatchBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JClassAlreadyExistsException; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JConditional; -import com.sun.codemodel.JDefinedClass; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JExpression; -import com.sun.codemodel.JFieldRef; -import com.sun.codemodel.JFieldVar; -import com.sun.codemodel.JInvocation; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JMod; -import com.sun.codemodel.JStatement; -import com.sun.codemodel.JTryBlock; -import com.sun.codemodel.JType; -import com.sun.codemodel.JVar; +import static com.sun.codemodel.JExpr.*; +import static com.sun.codemodel.JMod.*; +import static javax.lang.model.element.ElementKind.CONSTRUCTOR; public class APTCodeModelHelper { + public JClass typeMirrorToJClass(TypeMirror type, EComponentHolder holder) { + + if (type instanceof DeclaredType) { + DeclaredType declaredType = (DeclaredType) type; + + String declaredTypeName = declaredType.asElement().toString(); + + JClass declaredClass = holder.refClass(declaredTypeName); + + List typeArguments = declaredType.getTypeArguments(); + + List typeArgumentJClasses = new ArrayList(); + for (TypeMirror typeArgument : typeArguments) { + typeArgumentJClasses.add(typeMirrorToJClass(typeArgument, holder)); + } + if (typeArgumentJClasses.size() > 0) { + declaredClass = declaredClass.narrow(typeArgumentJClasses); + } + + return declaredClass; + } else if (type instanceof WildcardType) { + // TODO : At his time (01/2013), it is not possible to handle the + // super bound because code model does not offer a way to model + // statement like " ? super X" + // (see http://java.net/jira/browse/CODEMODEL-11) + WildcardType wildcardType = (WildcardType) type; + + TypeMirror extendsBound = wildcardType.getExtendsBound(); + + return typeMirrorToJClass(extendsBound, holder).wildcard(); + } else if (type instanceof ArrayType) { + ArrayType arrayType = (ArrayType) type; + + JClass refClass = typeMirrorToJClass(arrayType.getComponentType(), holder); + + return refClass.array(); + } else { + return holder.refClass(type.toString()); + } + } + public JClass typeMirrorToJClass(TypeMirror type, EBeanHolder holder) { if (type instanceof DeclaredType) { @@ -111,6 +129,44 @@ public Parameter(String name, JClass jClass) { } } + public JMethod overrideAnnotatedMethod(ExecutableElement executableElement, EComponentHolder holder) { + + String methodName = executableElement.getSimpleName().toString(); + + JClass returnType = typeMirrorToJClass(executableElement.getReturnType(), holder); + + List parameters = new ArrayList(); + for (VariableElement parameter : executableElement.getParameters()) { + String parameterName = parameter.getSimpleName().toString(); + JClass parameterClass = typeMirrorToJClass(parameter.asType(), holder); + parameters.add(new Parameter(parameterName, parameterClass)); + } + + JMethod existingMethod = findAlreadyGeneratedMethod(holder.getGeneratedClass(), methodName, parameters); + + if (existingMethod != null) { + return existingMethod; + } + + JMethod method = holder.getGeneratedClass().method(JMod.PUBLIC, returnType, methodName); + method.annotate(Override.class); + + for (VariableElement parameter : executableElement.getParameters()) { + String parameterName = parameter.getSimpleName().toString(); + JClass parameterClass = typeMirrorToJClass(parameter.asType(), holder); + JVar param = method.param(JMod.FINAL, parameterClass, parameterName); + } + + for (TypeMirror superThrownType : executableElement.getThrownTypes()) { + JClass thrownType = typeMirrorToJClass(superThrownType, holder); + method._throws(thrownType); + } + + callSuperMethod(method, holder, method.body()); + + return method; + } + public JMethod overrideAnnotatedMethod(ExecutableElement executableElement, EBeanHolder holder) { String methodName = executableElement.getSimpleName().toString(); @@ -168,6 +224,22 @@ private JMethod findAlreadyGeneratedMethod(JDefinedClass definedClass, String me return null; } + public void callSuperMethod(JMethod superMethod, EComponentHolder holder, JBlock callBlock) { + JExpression activitySuper = holder.getGeneratedClass().staticRef("super"); + JInvocation superCall = JExpr.invoke(activitySuper, superMethod); + + for (JVar param : superMethod.params()) { + superCall.arg(param); + } + + JType returnType = superMethod.type(); + if (returnType.fullName().equals("void")) { + callBlock.add(superCall); + } else { + callBlock._return(superCall); + } + } + public void callSuperMethod(JMethod superMethod, EBeanHolder holder, JBlock callBlock) { JExpression activitySuper = holder.generatedClass.staticRef("super"); JInvocation superCall = JExpr.invoke(activitySuper, superMethod); From ffb7bd12524076318d29efe38e5dee3b8d5a669d Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Fri, 31 May 2013 17:17:32 +0200 Subject: [PATCH 29/86] Implement ExtraHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/ExtraHandler.java | 139 ++++++++++++++++++ .../helper/APTCodeModelHelper.java | 3 +- .../holder/EActivityHolder.java | 55 ++++++- .../androidannotations/holder/HasExtras.java | 11 ++ 5 files changed, 207 insertions(+), 2 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasExtras.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index bf0e3c82dd..c400f787e2 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -47,6 +47,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new ResHandler(androidRes, processingEnvironment)); } add(new TransactionalHandler(processingEnvironment)); + add(new ExtraHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java new file mode 100644 index 0000000000..fddec3ae63 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java @@ -0,0 +1,139 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.Extra; +import org.androidannotations.helper.APTCodeModelHelper; +import org.androidannotations.helper.AnnotationHelper; +import org.androidannotations.helper.BundleHelper; +import org.androidannotations.helper.CaseHelper; +import org.androidannotations.holder.HasExtras; +import org.androidannotations.holder.HasIntentBuilder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.type.TypeKind; +import javax.lang.model.type.TypeMirror; +import javax.lang.model.util.Elements; +import javax.lang.model.util.Types; + +import static com.sun.codemodel.JExpr.*; +import static com.sun.codemodel.JMod.*; +import static org.androidannotations.helper.CanonicalNameConstants.*; + +public class ExtraHandler extends BaseAnnotationHandler { + + private final AnnotationHelper annotationHelper; + private final APTCodeModelHelper codeModelHelper = new APTCodeModelHelper(); + + public ExtraHandler(ProcessingEnvironment processingEnvironment) { + super(Extra.class, processingEnvironment); + annotationHelper = new AnnotationHelper(processingEnv); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + /* + * TODO since we override setIntent(), we should check that the + * setIntent() method can be overridden + */ + + validatorHelper.enclosingElementHasEActivity(element, validatedElements, valid); + + validatorHelper.isNotPrivate(element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, HasExtras holder) { + Extra annotation = element.getAnnotation(Extra.class); + String extraKey = annotation.value(); + String fieldName = element.getSimpleName().toString(); + if (extraKey.isEmpty()) { + extraKey = fieldName; + } + + JFieldVar extraKeyStaticField = createStaticExtraField(holder, extraKey, fieldName); + injectExtraInComponent(element, holder, extraKeyStaticField, fieldName); + + if (holder instanceof HasIntentBuilder) + createIntentInjectionMethod(element, (HasIntentBuilder) holder, extraKeyStaticField, fieldName); + } + + private JFieldVar createStaticExtraField(HasExtras holder, String extraKey, String fieldName) { + String staticFieldName; + if (fieldName.endsWith("Extra")) { + staticFieldName = CaseHelper.camelCaseToUpperSnakeCase(fieldName); + } else { + staticFieldName = CaseHelper.camelCaseToUpperSnakeCase(fieldName + "Extra"); + } + return holder.getGeneratedClass().field(PUBLIC | STATIC | FINAL, holder.classes().STRING, staticFieldName, lit(extraKey)); + } + + private void injectExtraInComponent(Element element, HasExtras hasExtras, JFieldVar extraKeyStaticField, String fieldName) { + JVar extras = hasExtras.getInjectExtras(); + JBlock injectExtrasBlock = hasExtras.getInjectExtrasBlock(); + + BundleHelper bundleHelper = new BundleHelper(annotationHelper, element); + + JFieldRef extraField = JExpr.ref(fieldName); + JBlock ifContainsKey = injectExtrasBlock._if(JExpr.invoke(extras, "containsKey").arg(extraKeyStaticField))._then(); + + JExpression restoreMethodCall = JExpr.invoke(extras, bundleHelper.getMethodNameToRestore()).arg(fieldName); + if (bundleHelper.restoreCallNeedCastStatement()) { + + JClass jclass = codeModelHelper.typeMirrorToJClass(element.asType(), hasExtras); + restoreMethodCall = JExpr.cast(jclass, restoreMethodCall); + + if (bundleHelper.restoreCallNeedsSuppressWarning()) { + JMethod injectExtrasMethod = hasExtras.getInjectExtrasMethod(); + if (injectExtrasMethod.annotations().size() == 0) { + injectExtrasMethod.annotate(SuppressWarnings.class).param("value", "unchecked"); + } + } + + } + ifContainsKey.assign(extraField, restoreMethodCall); + } + + private void createIntentInjectionMethod(Element element, HasIntentBuilder holder, JFieldVar extraKeyStaticField, String fieldName) { + JDefinedClass intentBuilderClass = holder.getIntentBuilderClass(); + JMethod method = intentBuilderClass.method(PUBLIC, intentBuilderClass, fieldName); + + boolean castToSerializable = false; + boolean castToParcelable = false; + TypeMirror extraType = element.asType(); + if (extraType.getKind() == TypeKind.DECLARED) { + Elements elementUtils = processingEnv.getElementUtils(); + Types typeUtils = processingEnv.getTypeUtils(); + TypeMirror parcelableType = elementUtils.getTypeElement(PARCELABLE).asType(); + if (!typeUtils.isSubtype(extraType, parcelableType)) { + TypeMirror stringType = elementUtils.getTypeElement(STRING).asType(); + if (!typeUtils.isSubtype(extraType, stringType)) { + castToSerializable = true; + } + } else { + TypeMirror serializableType = elementUtils.getTypeElement(SERIALIZABLE).asType(); + if (typeUtils.isSubtype(extraType, serializableType)) { + castToParcelable = true; + } + } + } + JClass paramClass = codeModelHelper.typeMirrorToJClass(extraType, holder); + JVar extraParam = method.param(paramClass, fieldName); + JBlock body = method.body(); + JInvocation invocation = body.invoke(holder.getIntentField(), "putExtra").arg(extraKeyStaticField); + if (castToSerializable) { + invocation.arg(cast(holder.classes().SERIALIZABLE, extraParam)); + } else if (castToParcelable) { + invocation.arg(cast(holder.classes().PARCELABLE, extraParam)); + } else { + invocation.arg(extraParam); + } + body._return(_this()); + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java index 87b880606a..399fdae359 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java @@ -17,6 +17,7 @@ import com.sun.codemodel.*; import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.holder.GeneratedClassHolder; import org.androidannotations.processing.EBeanHolder; import org.androidannotations.processing.EBeansHolder.Classes; @@ -37,7 +38,7 @@ public class APTCodeModelHelper { - public JClass typeMirrorToJClass(TypeMirror type, EComponentHolder holder) { + public JClass typeMirrorToJClass(TypeMirror type, GeneratedClassHolder holder) { if (type instanceof DeclaredType) { DeclaredType declaredType = (DeclaredType) type; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java index f580cd8c7b..b45815e4bc 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java @@ -18,11 +18,12 @@ import static com.sun.codemodel.JMod.PRIVATE; import static com.sun.codemodel.JMod.PUBLIC; -public class EActivityHolder extends EComponentHolder implements HasIntentBuilder, HasViewChanged { +public class EActivityHolder extends EComponentHolder implements HasIntentBuilder, HasViewChanged, HasExtras { private ViewNotifierHelper viewNotifierHelper; private GreenDroidHelper greenDroidHelper; private JMethod onCreate; + private JMethod setIntent; private JMethod setContentViewLayout; private JVar initSavedInstanceParam; private JDefinedClass intentBuilderClass; @@ -33,6 +34,9 @@ public class EActivityHolder extends EComponentHolder implements HasIntentBuilde private JMethod findNativeFragmentByTag; private JMethod findSupportFragmentByTag; private RoboGuiceHolder roboGuiceHolder; + private JMethod injectExtrasMethod; + private JBlock injectExtrasBlock; + private JVar injectExtras; public EActivityHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); @@ -61,6 +65,13 @@ public JMethod getOnCreate() { return onCreate; } + public JMethod getSetIntent() { + if (setIntent == null) { + setSetIntent(); + } + return setIntent; + } + protected void setOnCreate() { onCreate = generatedClass.method(PUBLIC, codeModel().VOID, "onCreate"); onCreate.annotate(Override.class); @@ -117,6 +128,14 @@ protected void setOnNewIntent() { roboGuiceHolder.onNewIntentAfterSuperBlock = body.block(); } + private void setSetIntent() { + setIntent = generatedClass.method(PUBLIC, codeModel().VOID, "setIntent"); + setIntent.annotate(Override.class); + JVar methodParam = setIntent.param(classes().INTENT, "newIntent"); + JBlock setIntentBody = setIntent.body(); + setIntentBody.invoke(_super(), setIntent).arg(methodParam); + } + protected void setOnStop() { JMethod method = generatedClass.method(JMod.PUBLIC, codeModel().VOID, "onStop"); method.annotate(Override.class); @@ -400,4 +419,38 @@ public void setGetInjector() { method.body()._return(castApplication.invoke("getInjector")); roboGuiceHolder.getInjector = method; } + + @Override + public JMethod getInjectExtrasMethod() { + if (injectExtrasMethod == null) { + setInjectExtras(); + } + return injectExtrasMethod; + } + + @Override + public JBlock getInjectExtrasBlock() { + if (injectExtrasBlock == null) { + setInjectExtras(); + } + return injectExtrasBlock; + } + + @Override + public JVar getInjectExtras() { + if (injectExtras == null) { + setInjectExtras(); + } + return injectExtras; + } + + private void setInjectExtras() { + injectExtrasMethod = generatedClass.method(PRIVATE, codeModel().VOID, "injectExtras_"); + JBlock injectExtrasBody = injectExtrasMethod.body(); + injectExtras = injectExtrasBody.decl(classes().BUNDLE, "extras_", invoke("getIntent").invoke("getExtras")); + injectExtrasBlock = injectExtrasBody._if(injectExtras.ne(_null()))._then(); + + getSetIntent().body().invoke(injectExtrasMethod); + getInit().body().invoke(injectExtrasMethod); + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasExtras.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasExtras.java new file mode 100644 index 0000000000..8aca3b57d8 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasExtras.java @@ -0,0 +1,11 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JVar; + +public interface HasExtras extends GeneratedClassHolder { + JMethod getInjectExtrasMethod(); + JBlock getInjectExtrasBlock(); + JVar getInjectExtras(); +} From ec481d75b456f14fe157339e9f03755eaad32109 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Fri, 31 May 2013 14:04:14 +0200 Subject: [PATCH 30/86] Implement FragmentArgHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/FragmentArgHandler.java | 102 ++++++++++++++++++ .../holder/EFragmentHolder.java | 39 +++++++ 3 files changed, 142 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentArgHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index c400f787e2..73eb4e45ef 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -48,6 +48,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { } add(new TransactionalHandler(processingEnvironment)); add(new ExtraHandler(processingEnvironment)); + add(new FragmentArgHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentArgHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentArgHandler.java new file mode 100644 index 0000000000..564ace5152 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentArgHandler.java @@ -0,0 +1,102 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.FragmentArg; +import org.androidannotations.helper.APTCodeModelHelper; +import org.androidannotations.helper.AnnotationHelper; +import org.androidannotations.helper.BundleHelper; +import org.androidannotations.helper.CaseHelper; +import org.androidannotations.holder.EFragmentHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.type.TypeMirror; + +import static com.sun.codemodel.JExpr._this; +import static com.sun.codemodel.JExpr.lit; +import static com.sun.codemodel.JMod.*; + +public class FragmentArgHandler extends BaseAnnotationHandler { + + private final AnnotationHelper annotationHelper; + private final APTCodeModelHelper codeModelHelper = new APTCodeModelHelper(); + + public FragmentArgHandler(ProcessingEnvironment processingEnvironment) { + super(FragmentArg.class, processingEnvironment); + annotationHelper = new AnnotationHelper(processingEnv); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEFragment(element, validatedElements, valid); + + validatorHelper.isNotPrivate(element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EFragmentHolder holder) { + FragmentArg annotation = element.getAnnotation(FragmentArg.class); + String argKey = annotation.value(); + String fieldName = element.getSimpleName().toString(); + + if (argKey.isEmpty()) { + argKey = fieldName; + } + + BundleHelper bundleHelper = new BundleHelper(annotationHelper, element); + JFieldVar argKeyStaticField = createStaticArgField(holder, argKey, fieldName); + injectArgInComponent(element, holder, bundleHelper, argKeyStaticField, fieldName); + createBuilderInjectionMethod(element, holder, bundleHelper, argKeyStaticField, fieldName); + } + + private JFieldVar createStaticArgField(EFragmentHolder holder, String argKey, String fieldName) { + String staticFieldName; + if (fieldName.endsWith("Arg")) { + staticFieldName = CaseHelper.camelCaseToUpperSnakeCase(fieldName); + } else { + staticFieldName = CaseHelper.camelCaseToUpperSnakeCase(fieldName + "Arg"); + } + return holder.getGeneratedClass().field(PUBLIC | STATIC | FINAL, holder.classes().STRING, staticFieldName, lit(argKey)); + } + + private void injectArgInComponent(Element element, EFragmentHolder holder, BundleHelper bundleHelper, JFieldVar extraKeyStaticField, String fieldName) { + JVar bundle = holder.getInjectBundleArgs(); + JBlock injectExtrasBlock = holder.getInjectArgsBlock(); + JFieldRef extraField = JExpr.ref(fieldName); + + JBlock ifContainsKey = injectExtrasBlock._if(JExpr.invoke(bundle, "containsKey").arg(extraKeyStaticField))._then(); + JExpression restoreMethodCall = JExpr.invoke(bundle, bundleHelper.getMethodNameToRestore()).arg(extraKeyStaticField); + if (bundleHelper.restoreCallNeedCastStatement()) { + + JClass jclass = codeModelHelper.typeMirrorToJClass(element.asType(), holder); + restoreMethodCall = JExpr.cast(jclass, restoreMethodCall); + + if (bundleHelper.restoreCallNeedsSuppressWarning()) { + JMethod injectExtrasMethod = holder.getInjectArgsMethod(); + if (injectExtrasMethod.annotations().size() == 0) { + injectExtrasMethod.annotate(SuppressWarnings.class).param("value", "unchecked"); + } + } + + } + ifContainsKey.assign(extraField, restoreMethodCall); + } + + private void createBuilderInjectionMethod(Element element, EFragmentHolder holder, BundleHelper bundleHelper, JFieldVar argKeyStaticField, String fieldName) { + JDefinedClass builderClass = holder.getBuilderClass(); + JVar builderArgsField = holder.getBuilderArgsField(); + TypeMirror elementType = element.asType(); + JClass paramClass = codeModelHelper.typeMirrorToJClass(elementType, holder); + + JMethod method = builderClass.method(PUBLIC, builderClass, fieldName); + JVar arg = method.param(paramClass, fieldName); + method.body().invoke(builderArgsField, bundleHelper.getMethodNameToSave()).arg(argKeyStaticField).arg(arg); + method.body()._return(_this()); + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java index 6680b05615..7d5d6cec98 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java @@ -25,6 +25,9 @@ public class EFragmentHolder extends EComponentHolder implements HasViewChanged private JMethod findSupportFragmentById; private JMethod findNativeFragmentByTag; private JMethod findSupportFragmentByTag; + private JMethod injectArgsMethod; + private JBlock injectArgsBlock; + private JVar injectBundleArgs; public EFragmentHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); @@ -227,5 +230,41 @@ public JVar getContainer() { return container; } + public JDefinedClass getBuilderClass() { + return fragmentBuilderClass; + } + + public JFieldVar getBuilderArgsField() { + return fragmentArgumentsBuilderField; + } + + public JMethod getInjectArgsMethod() { + if (injectArgsMethod == null) { + setInjectArgs(); + } + return injectArgsMethod; + } + + public JBlock getInjectArgsBlock() { + if (injectArgsBlock == null) { + setInjectArgs(); + } + return injectArgsBlock; + } + public JVar getInjectBundleArgs() { + if (injectBundleArgs == null) { + setInjectArgs(); + } + return injectBundleArgs; + } + + private void setInjectArgs() { + injectArgsMethod = generatedClass.method(PRIVATE, codeModel().VOID, "injectFragmentArguments_"); + JBlock injectExtrasBody = injectArgsMethod.body(); + injectBundleArgs = injectExtrasBody.decl(classes().BUNDLE, "args_", invoke("getArguments")); + injectArgsBlock = injectExtrasBody._if(injectBundleArgs.ne(_null()))._then(); + + getInit().body().invoke(injectArgsMethod); + } } From b822da41add1be4b2159b6654bc9b13967d2aa79 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Fri, 31 May 2013 15:57:42 +0200 Subject: [PATCH 31/86] Implement SystemServiceHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/SystemServiceHandler.java | 49 +++++++++++++++++++ .../model/AndroidSystemServices.java | 26 ++++++++-- 3 files changed, 71 insertions(+), 5 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 73eb4e45ef..4d7e3f4712 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -49,6 +49,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new TransactionalHandler(processingEnvironment)); add(new ExtraHandler(processingEnvironment)); add(new FragmentArgHandler(processingEnvironment)); + add(new SystemServiceHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java new file mode 100644 index 0000000000..2d352eaf75 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java @@ -0,0 +1,49 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JFieldRef; +import org.androidannotations.annotations.SystemService; +import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.type.TypeMirror; + +import static com.sun.codemodel.JExpr.cast; +import static com.sun.codemodel.JExpr.ref; + +public class SystemServiceHandler extends BaseAnnotationHandler { + + public SystemServiceHandler(ProcessingEnvironment processingEnvironment) { + super(SystemService.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); + + validatorHelper.androidService(androidSystemServices, element, valid); + + validatorHelper.isNotPrivate(element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EComponentHolder holder) { + String fieldName = element.getSimpleName().toString(); + + TypeMirror serviceType = element.asType(); + String fieldTypeQualifiedName = serviceType.toString(); + + JFieldRef serviceRef = androidSystemServices.getServiceConstant(serviceType, holder); + + JBlock methodBody = holder.getInit().body(); + + methodBody.assign(ref(fieldName), cast(holder.refClass(fieldTypeQualifiedName), holder.getContextRef().invoke("getSystemService").arg(serviceRef))); + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/AndroidSystemServices.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/AndroidSystemServices.java index 93bc242f57..459b438b18 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/AndroidSystemServices.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/AndroidSystemServices.java @@ -15,13 +15,13 @@ */ package org.androidannotations.model; -import java.util.HashMap; -import java.util.Map; +import com.sun.codemodel.JFieldRef; +import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.processing.EBeanHolder; import javax.lang.model.type.TypeMirror; - -import org.androidannotations.processing.EBeanHolder; -import com.sun.codemodel.JFieldRef; +import java.util.HashMap; +import java.util.Map; public class AndroidSystemServices { @@ -73,10 +73,26 @@ public String getServiceConstant(TypeMirror serviceType) { return registeredServices.get(serviceType.toString()); } + public JFieldRef getServiceConstant(TypeMirror serviceType, EComponentHolder holder) { + return extractIdStaticRef(holder, registeredServices.get(serviceType.toString())); + } + public JFieldRef getServiceConstant(TypeMirror serviceType, EBeanHolder holder) { return extractIdStaticRef(holder, registeredServices.get(serviceType.toString())); } + private JFieldRef extractIdStaticRef(EComponentHolder holder, String staticFieldQualifiedName) { + if (staticFieldQualifiedName != null) { + int fieldSuffix = staticFieldQualifiedName.lastIndexOf('.'); + String fieldName = staticFieldQualifiedName.substring(fieldSuffix + 1); + String className = staticFieldQualifiedName.substring(0, fieldSuffix); + + return holder.refClass(className).staticRef(fieldName); + } else { + return null; + } + } + private JFieldRef extractIdStaticRef(EBeanHolder holder, String staticFieldQualifiedName) { if (staticFieldQualifiedName != null) { int fieldSuffix = staticFieldQualifiedName.lastIndexOf('.'); From 26ac5e881c74e4488863d17cfdd17aaffb5ed207 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Sun, 2 Jun 2013 22:47:59 +0200 Subject: [PATCH 32/86] Implement InstanceStateHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/InstanceStateHandler.java | 70 ++++++++++ .../holder/EActivityHolder.java | 24 +++- .../holder/EFragmentHolder.java | 24 +++- .../holder/HasInstanceState.java | 10 ++ .../holder/InstanceStateHolder.java | 127 ++++++++++++++++++ 6 files changed, 254 insertions(+), 2 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/InstanceStateHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasInstanceState.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/InstanceStateHolder.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 4d7e3f4712..fd51d61b29 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -52,6 +52,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new SystemServiceHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); + add(new InstanceStateHandler(processingEnvironment)); } private void add(AnnotationHandler annotationHandler) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/InstanceStateHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/InstanceStateHandler.java new file mode 100644 index 0000000000..a66460b050 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/InstanceStateHandler.java @@ -0,0 +1,70 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.InstanceState; +import org.androidannotations.helper.APTCodeModelHelper; +import org.androidannotations.helper.AnnotationHelper; +import org.androidannotations.helper.BundleHelper; +import org.androidannotations.holder.HasInstanceState; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + +import static com.sun.codemodel.JExpr.ref; + +public class InstanceStateHandler extends BaseAnnotationHandler { + + public InstanceStateHandler(ProcessingEnvironment processingEnvironment) { + super(InstanceState.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEActivityOrEFragment(element, validatedElements, valid); + + validatorHelper.isNotPrivate(element, valid); + + validatorHelper.canBeSavedAsInstanceState(element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, HasInstanceState holder) { + String fieldName = element.getSimpleName().toString(); + + JBlock saveStateBody = holder.getSaveStateMethodBody(); + JVar saveStateBundleParam = holder.getSaveStateBundleParam(); + JMethod restoreStateMethod = holder.getRestoreStateMethod(); + JBlock restoreStateBody = restoreStateMethod.body(); + JVar restoreStateBundleParam = holder.getRestoreStateBundleParam(); + + AnnotationHelper annotationHelper = new AnnotationHelper(processingEnv); + BundleHelper bundleHelper = new BundleHelper(annotationHelper, element); + APTCodeModelHelper codeModelHelper = new APTCodeModelHelper(); + + JFieldRef ref = ref(fieldName); + saveStateBody.invoke(saveStateBundleParam, bundleHelper.getMethodNameToSave()).arg(fieldName).arg(ref); + + JInvocation restoreMethodCall = JExpr.invoke(restoreStateBundleParam, bundleHelper.getMethodNameToRestore()).arg(fieldName); + if (bundleHelper.restoreCallNeedCastStatement()) { + + JClass jclass = codeModelHelper.typeMirrorToJClass(element.asType(), holder); + JExpression castStatement = JExpr.cast(jclass, restoreMethodCall); + restoreStateBody.assign(ref, castStatement); + + if (bundleHelper.restoreCallNeedsSuppressWarning()) { + if (restoreStateMethod.annotations().size() == 0) { + restoreStateMethod.annotate(SuppressWarnings.class).param("value", "unchecked"); + } + } + + } else { + restoreStateBody.assign(ref, restoreMethodCall); + } + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java index b45815e4bc..79762ed001 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java @@ -18,7 +18,7 @@ import static com.sun.codemodel.JMod.PRIVATE; import static com.sun.codemodel.JMod.PUBLIC; -public class EActivityHolder extends EComponentHolder implements HasIntentBuilder, HasViewChanged, HasExtras { +public class EActivityHolder extends EComponentHolder implements HasIntentBuilder, HasViewChanged, HasExtras, HasInstanceState { private ViewNotifierHelper viewNotifierHelper; private GreenDroidHelper greenDroidHelper; @@ -33,6 +33,7 @@ public class EActivityHolder extends EComponentHolder implements HasIntentBuilde private JMethod findSupportFragmentById; private JMethod findNativeFragmentByTag; private JMethod findSupportFragmentByTag; + private InstanceStateHolder instanceStateHolder; private RoboGuiceHolder roboGuiceHolder; private JMethod injectExtrasMethod; private JBlock injectExtrasBlock; @@ -41,6 +42,7 @@ public class EActivityHolder extends EComponentHolder implements HasIntentBuilde public EActivityHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); viewNotifierHelper = new ViewNotifierHelper(this); + instanceStateHolder = new InstanceStateHolder(this); createIntentBuilder(); handleBackPressed(); } @@ -453,4 +455,24 @@ private void setInjectExtras() { getSetIntent().body().invoke(injectExtrasMethod); getInit().body().invoke(injectExtrasMethod); } + + @Override + public JBlock getSaveStateMethodBody() { + return instanceStateHolder.getSaveStateMethodBody(); + } + + @Override + public JVar getSaveStateBundleParam() { + return instanceStateHolder.getSaveStateBundleParam(); + } + + @Override + public JMethod getRestoreStateMethod() { + return instanceStateHolder.getRestoreStateMethod(); + } + + @Override + public JVar getRestoreStateBundleParam() { + return instanceStateHolder.getRestoreStateBundleParam(); + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java index 7d5d6cec98..0cb77d3f35 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java @@ -11,7 +11,7 @@ import static com.sun.codemodel.JExpr.*; import static com.sun.codemodel.JMod.*; -public class EFragmentHolder extends EComponentHolder implements HasViewChanged { +public class EFragmentHolder extends EComponentHolder implements HasViewChanged, HasInstanceState { private ViewNotifierHelper viewNotifierHelper; private JFieldVar contentView; @@ -28,10 +28,12 @@ public class EFragmentHolder extends EComponentHolder implements HasViewChanged private JMethod injectArgsMethod; private JBlock injectArgsBlock; private JVar injectBundleArgs; + private InstanceStateHolder instanceStateHolder; public EFragmentHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); viewNotifierHelper = new ViewNotifierHelper(this); + instanceStateHolder = new InstanceStateHolder(this); createOnCreate(); createOnViewCreated(); createFragmentBuilder(); @@ -267,4 +269,24 @@ private void setInjectArgs() { getInit().body().invoke(injectArgsMethod); } + + @Override + public JBlock getSaveStateMethodBody() { + return instanceStateHolder.getSaveStateMethodBody(); + } + + @Override + public JVar getSaveStateBundleParam() { + return instanceStateHolder.getSaveStateBundleParam(); + } + + @Override + public JMethod getRestoreStateMethod() { + return instanceStateHolder.getRestoreStateMethod(); + } + + @Override + public JVar getRestoreStateBundleParam() { + return instanceStateHolder.getRestoreStateBundleParam(); + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasInstanceState.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasInstanceState.java new file mode 100644 index 0000000000..7d6cb988b3 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasInstanceState.java @@ -0,0 +1,10 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.*; + +public interface HasInstanceState extends GeneratedClassHolder { + JBlock getSaveStateMethodBody(); + JVar getSaveStateBundleParam(); + JMethod getRestoreStateMethod(); + JVar getRestoreStateBundleParam(); +} \ No newline at end of file diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/InstanceStateHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/InstanceStateHolder.java new file mode 100644 index 0000000000..09e555d91d --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/InstanceStateHolder.java @@ -0,0 +1,127 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.*; +import org.androidannotations.process.ProcessHolder; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; + +import static com.sun.codemodel.JExpr._null; +import static com.sun.codemodel.JExpr.ref; +import static com.sun.codemodel.JMod.PRIVATE; +import static com.sun.codemodel.JMod.PUBLIC; + +public class InstanceStateHolder implements HasInstanceState { + + private EComponentHolder holder; + private JBlock saveStateMethodBody; + private JVar saveStateBundleParam; + private JMethod restoreStateMethod; + private JVar restoreStateBundleParam; + + public InstanceStateHolder(EComponentHolder holder) { + this.holder = holder; + } + + @Override + public JBlock getSaveStateMethodBody() { + if (saveStateMethodBody == null) { + setSaveStateMethod(); + } + return saveStateMethodBody; + } + + @Override + public JVar getSaveStateBundleParam() { + if (saveStateBundleParam == null) { + setSaveStateMethod(); + } + return saveStateBundleParam; + } + + private void setSaveStateMethod() { + JMethod method = getGeneratedClass().method(PUBLIC, codeModel().VOID, "onSaveInstanceState"); + method.annotate(Override.class); + saveStateBundleParam = method.param(classes().BUNDLE, "bundle"); + + saveStateMethodBody = method.body(); + + saveStateMethodBody.invoke(JExpr._super(), "onSaveInstanceState").arg(saveStateBundleParam); + } + + @Override + public JMethod getRestoreStateMethod() { + if (restoreStateMethod == null) { + setRestoreStateMethod(); + } + return restoreStateMethod; + } + + @Override + public JVar getRestoreStateBundleParam() { + if (restoreStateBundleParam == null) { + setRestoreStateMethod(); + } + return restoreStateBundleParam; + } + + private void setRestoreStateMethod() { + restoreStateMethod = getGeneratedClass().method(PRIVATE, codeModel().VOID, "restoreSavedInstanceState_"); + restoreStateBundleParam = restoreStateMethod.param(classes().BUNDLE, "savedInstanceState"); + getInit().body().invoke(restoreStateMethod).arg(restoreStateBundleParam); + + restoreStateMethod.body() // + ._if(ref("savedInstanceState").eq(_null())) // + ._then()._return(); + } + + public JMethod getInit() { + return holder.getInit(); + } + + @Override + public JDefinedClass getGeneratedClass() { + return holder.getGeneratedClass(); + } + + @Override + public JCodeModel codeModel() { + return holder.codeModel(); + } + + @Override + public ProcessHolder.Classes classes() { + return holder.classes(); + } + + @Override + public TypeElement getAnnotatedElement() { + return holder.getAnnotatedElement(); + } + + @Override + public ProcessingEnvironment processingEnvironment() { + return holder.processingEnvironment(); + } + + @Override + public JClass refClass(String fullyQualifiedClassName) { + return holder.refClass(fullyQualifiedClassName); + } + + @Override + public JClass refClass(Class clazz) { + return holder.refClass(clazz); + } + + @Override + public JDefinedClass definedClass(String fullyQualifiedClassName) { + return holder.definedClass(fullyQualifiedClassName); + } + + @Override + public void generateApiClass(Element originatingElement, Class apiClass) { + holder.generateApiClass(originatingElement, apiClass); + } +} From a49f68c3b7966dcb3f8f62ef3ddf3875a39fe7d4 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Mon, 3 Jun 2013 15:48:51 +0200 Subject: [PATCH 33/86] Implement RestHandler --- .../handler/AnnotationHandlers.java | 2 + .../handler/rest/RestHandler.java | 104 ++++++++++++ .../androidannotations/holder/RestHolder.java | 151 ++++++++++++++++++ .../process/ProcessHolder.java | 16 +- 4 files changed, 269 insertions(+), 4 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RestHolder.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index fd51d61b29..ef65f32335 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -1,5 +1,6 @@ package org.androidannotations.handler; +import org.androidannotations.handler.rest.RestHandler; import org.androidannotations.helper.AndroidManifest; import org.androidannotations.holder.GeneratedClassHolder; import org.androidannotations.model.AndroidRes; @@ -50,6 +51,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new ExtraHandler(processingEnvironment)); add(new FragmentArgHandler(processingEnvironment)); add(new SystemServiceHandler(processingEnvironment)); + add(new RestHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestHandler.java new file mode 100644 index 0000000000..94fdee2b70 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestHandler.java @@ -0,0 +1,104 @@ +package org.androidannotations.handler.rest; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JFieldVar; +import org.androidannotations.annotations.rest.Rest; +import org.androidannotations.handler.BaseAnnotationHandler; +import org.androidannotations.handler.GeneratingAnnotationHandler; +import org.androidannotations.helper.AnnotationHelper; +import org.androidannotations.holder.RestHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.ProcessHolder; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; +import javax.lang.model.type.DeclaredType; +import java.util.List; + +import static com.sun.codemodel.JExpr.*; +import static org.androidannotations.helper.CanonicalNameConstants.ARRAYLIST; +import static org.androidannotations.helper.CanonicalNameConstants.CLIENT_HTTP_REQUEST_INTERCEPTOR; + +public class RestHandler extends BaseAnnotationHandler implements GeneratingAnnotationHandler { + + private final AnnotationHelper annotationHelper; + + public RestHandler(ProcessingEnvironment processingEnvironment) { + super(Rest.class, processingEnvironment); + annotationHelper = new AnnotationHelper(processingEnv); + } + + @Override + public RestHolder createGeneratedClassHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + return new RestHolder(processHolder, annotatedElement); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + TypeElement typeElement = (TypeElement) element; + + validatorHelper.notAlreadyValidated(element, validatedElements, valid); + + validatorHelper.hasSpringAndroidJars(element, valid); + + validatorHelper.isInterface(typeElement, valid); + + validatorHelper.isTopLevel(typeElement, valid); + + validatorHelper.doesNotExtendOtherInterfaces(typeElement, valid); + + validatorHelper.unannotatedMethodReturnsRestTemplate(typeElement, valid); + + validatorHelper.validateConverters(element, valid); + + validatorHelper.validateInterceptors(element, valid); + + validatorHelper.hasInternetPermission(typeElement, androidManifest, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, RestHolder holder) { + setRootUrl(element, holder); + setConverters(element, holder); + setInterceptors(element, holder); + } + + private void setRootUrl(Element element, RestHolder holder) { + TypeElement typeElement = (TypeElement) element; + String rootUrl = typeElement.getAnnotation(Rest.class).rootUrl(); + holder.getInit().body().assign(holder.getRootUrlField(), lit(rootUrl)); + } + + private void setConverters(Element element, RestHolder holder) { + List converters = annotationHelper.extractAnnotationClassArrayParameter(element, getTarget(), "converters"); + JFieldVar restTemplateField = holder.getRestTemplateField(); + JBlock init = holder.getInit().body(); + for (DeclaredType converterType : converters) { + JClass converterClass = holder.refClass(converterType.toString()); + init.add(invoke(restTemplateField, "getMessageConverters").invoke("add").arg(_new(converterClass))); + } + } + + private void setInterceptors(Element element, RestHolder holder) { + List interceptors = annotationHelper.extractAnnotationClassArrayParameter(element, getTarget(), "interceptors"); + if (interceptors != null) { + JClass listClass = holder.refClass(ARRAYLIST); + JClass clientInterceptorClass = holder.refClass(CLIENT_HTTP_REQUEST_INTERCEPTOR); + listClass = listClass.narrow(clientInterceptorClass); + JFieldVar restTemplateField = holder.getRestTemplateField(); + JBlock init = holder.getInit().body(); + init.add(invoke(restTemplateField, "setInterceptors").arg(_new(listClass))); + for (DeclaredType interceptorType : interceptors) { + JClass interceptorClass = holder.refClass(interceptorType.toString()); + init.add(invoke(restTemplateField, "getInterceptors").invoke("add").arg(_new(interceptorClass))); + } + } + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RestHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RestHolder.java new file mode 100644 index 0000000000..6127df7db7 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RestHolder.java @@ -0,0 +1,151 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.*; +import org.androidannotations.helper.ModelConstants; +import org.androidannotations.process.ProcessHolder; + +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.TypeKind; +import javax.lang.model.util.ElementFilter; +import java.util.List; + +import static com.sun.codemodel.JExpr._new; +import static com.sun.codemodel.JExpr._this; +import static com.sun.codemodel.JMod.FINAL; +import static com.sun.codemodel.JMod.PUBLIC; +import static org.androidannotations.helper.CanonicalNameConstants.REST_TEMPLATE; +import static org.androidannotations.helper.CanonicalNameConstants.STRING; + +public class RestHolder extends BaseGeneratedClassHolder { + + private JMethod init; + private JFieldVar rootUrlField; + private JFieldVar restTemplateField; + + public RestHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + super(processHolder, annotatedElement); + implementMethods(); + } + + @Override + protected void setGeneratedClass() throws Exception { + String annotatedComponentQualifiedName = annotatedElement.getQualifiedName().toString(); + String subComponentQualifiedName = annotatedComponentQualifiedName + ModelConstants.GENERATION_SUFFIX; + JClass annotatedComponent = codeModel().directClass(annotatedComponentQualifiedName); + generatedClass = codeModel()._class(PUBLIC | FINAL, subComponentQualifiedName, ClassType.CLASS); + generatedClass._implements(annotatedComponent); + } + + private void implementMethods() { + List enclosedElements = annotatedElement.getEnclosedElements(); + List methods = ElementFilter.methodsIn(enclosedElements); + boolean getRestTemplateImplemented = false, setRestTemplateImplemented = false, getRootUrlImplemented = false, setRootUrlImplemented = false; + for (ExecutableElement method : methods) { + List parameters = method.getParameters(); + + if (!getRestTemplateImplemented // + && method.getParameters().size() == 0 // + && method.getReturnType().toString().equals(REST_TEMPLATE)) { + + implementGetRestTemplateMethod(method); + getRestTemplateImplemented = true; + } + + if (!setRestTemplateImplemented // + && parameters.size() == 1 // + && parameters.get(0).asType().toString().equals(REST_TEMPLATE) // + && method.getReturnType().getKind() == TypeKind.VOID) { + + implementSetRestTemplateMethod(method); + setRestTemplateImplemented = true; + } + + if (!getRootUrlImplemented // + && parameters.size() == 0 // + && method.getReturnType().toString().equals(STRING) // + && method.getSimpleName().toString().equals("getRootUrl")) { + implementGetRootUrlMethod(method); + getRootUrlImplemented = true; + } + + if (!setRootUrlImplemented // + && method.getSimpleName().toString().equals("setRootUrl") + && method.getReturnType().getKind() == TypeKind.VOID // + && parameters.size() == 1 // + && parameters.get(0).asType().toString().equals(STRING)) { + + implementSetRootUrl(method); + setRootUrlImplemented = true; + } + } + } + + private void implementGetRestTemplateMethod(ExecutableElement method) { + String methodName = method.getSimpleName().toString(); + JMethod getRestTemplateMethod = getGeneratedClass().method(JMod.PUBLIC, classes().REST_TEMPLATE, methodName); + getRestTemplateMethod.annotate(Override.class); + getRestTemplateMethod.body()._return(getRestTemplateField()); + } + + private void implementSetRestTemplateMethod(ExecutableElement method) { + String methodName = method.getSimpleName().toString(); + VariableElement firstParameter = method.getParameters().get(0); + JMethod setRestTemplateMethod = getGeneratedClass().method(JMod.PUBLIC, codeModel().VOID, methodName); + setRestTemplateMethod.annotate(Override.class); + JVar restTemplateSetterParam = setRestTemplateMethod.param(classes().REST_TEMPLATE, firstParameter.getSimpleName().toString()); + setRestTemplateMethod.body().assign(_this().ref(getRestTemplateField()), restTemplateSetterParam); + } + + private void implementGetRootUrlMethod(ExecutableElement method) { + String methodName = method.getSimpleName().toString(); + JMethod getRootUrlMethod = getGeneratedClass().method(JMod.PUBLIC, processHolder.refClass(STRING), methodName); + getRootUrlMethod.annotate(Override.class); + getRootUrlMethod.body()._return(getRootUrlField()); + } + + private void implementSetRootUrl(ExecutableElement method) { + String methodName = method.getSimpleName().toString(); + VariableElement firstParameter = method.getParameters().get(0); + JMethod setRootUrlMethod = getGeneratedClass().method(JMod.PUBLIC, codeModel().VOID, methodName); + setRootUrlMethod.annotate(Override.class); + JVar rootUrlSetterParam = setRootUrlMethod.param(classes().STRING, firstParameter.getSimpleName().toString()); + setRootUrlMethod.body().assign(_this().ref(getRootUrlField()), rootUrlSetterParam); + } + + public JMethod getInit() { + if (init == null) { + setInit(); + } + return init; + } + + private void setInit() { + init = getGeneratedClass().constructor(JMod.PUBLIC); + } + + public JFieldVar getRootUrlField() { + if (rootUrlField == null) { + setRootUrlField(); + } + return rootUrlField; + } + + private void setRootUrlField() { + rootUrlField = getGeneratedClass().field(JMod.PRIVATE, classes().STRING, "rootUrl"); + } + + public JFieldVar getRestTemplateField() { + if (restTemplateField == null) { + setRestTemplateField(); + } + return restTemplateField; + } + + private void setRestTemplateField() { + restTemplateField = getGeneratedClass().field(JMod.PRIVATE, classes().REST_TEMPLATE, "restTemplate"); + getInit().body().assign(restTemplateField, _new(classes().REST_TEMPLATE)); + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ProcessHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ProcessHolder.java index 6cd176dfac..fbc92db31a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ProcessHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ProcessHolder.java @@ -29,10 +29,7 @@ import java.io.InputStream; import java.io.Serializable; import java.sql.SQLException; -import java.util.HashMap; -import java.util.HashSet; -import java.util.Map; -import java.util.Set; +import java.util.*; public class ProcessHolder { @@ -51,6 +48,7 @@ public class Classes { public final JClass INPUT_STREAM = refClass(InputStream.class); public final JClass FILE_INPUT_STREAM = refClass(FileInputStream.class); public final JClass SQL_EXCEPTION = refClass(SQLException.class); + public final JClass COLLECTIONS = refClass(Collections.class); /* * Android @@ -149,6 +147,16 @@ public class Classes { public final JClass SCHEME_REGISTRY = refClass(CanonicalNameConstants.SCHEME_REGISTRY); public final JClass SINGLE_CLIENT_CONN_MANAGER = refClass(CanonicalNameConstants.SINGLE_CLIENT_CONN_MANAGER); + /* + * SpringFramework + */ + public final JClass REST_TEMPLATE = refClass(CanonicalNameConstants.REST_TEMPLATE); + public final JClass HTTP_METHOD = refClass(CanonicalNameConstants.HTTP_METHOD); + public final JClass HTTP_ENTITY = refClass(CanonicalNameConstants.HTTP_ENTITY); + public final JClass HTTP_HEADERS = refClass(CanonicalNameConstants.HTTP_HEADERS); + public final JClass MEDIA_TYPE = refClass(CanonicalNameConstants.MEDIA_TYPE); + public final JClass RESPONSE_ENTITY = refClass(CanonicalNameConstants.RESPONSE_ENTITY); + } private final Map generatedClassHolders = new HashMap(); From 2c20fecd80e56a56b46e1a0df432d73c672205db Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Mon, 3 Jun 2013 15:53:05 +0200 Subject: [PATCH 34/86] Implement RestMethodHandler (abstract) --- .../handler/rest/RestMethodHandler.java | 127 +++++++++ .../helper/RestAnnotationHelper.java | 263 ++++++++++++++++-- 2 files changed, 372 insertions(+), 18 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java new file mode 100644 index 0000000000..a99abdd788 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java @@ -0,0 +1,127 @@ +package org.androidannotations.handler.rest; + +import com.sun.codemodel.*; +import org.androidannotations.handler.BaseAnnotationHandler; +import org.androidannotations.helper.APTCodeModelHelper; +import org.androidannotations.helper.RestAnnotationHelper; +import org.androidannotations.holder.RestHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +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 java.util.List; +import java.util.Locale; +import java.util.TreeMap; + +public abstract class RestMethodHandler extends BaseAnnotationHandler { + + protected final RestAnnotationHelper restAnnotationHelper; + protected final APTCodeModelHelper codeModelHelper; + + public RestMethodHandler(Class targetClass, ProcessingEnvironment processingEnvironment) { + super(targetClass, processingEnvironment); + restAnnotationHelper = new RestAnnotationHelper(processingEnv, getTarget()); + codeModelHelper = new APTCodeModelHelper(); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.notAlreadyValidated(element, validatedElements, valid); + + validatorHelper.enclosingElementHasRestAnnotation(element, validatedElements, valid); + + validatorHelper.throwsOnlyRestClientException((ExecutableElement) element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, RestHolder holder) { + ExecutableElement executableElement = (ExecutableElement) element; + String methodName = element.getSimpleName().toString(); + JClass methodReturnClass = getMethodReturnClass(element, holder); + + // Creating method signature + JMethod method = holder.getGeneratedClass().method(JMod.PUBLIC, methodReturnClass, methodName); + method.annotate(Override.class); + TreeMap params = addMethodParams(executableElement, holder, method); + JBlock methodBody = method.body(); + + // RestTemplate exchange() method call + JInvocation exchangeCall = JExpr.invoke(holder.getRestTemplateField(), "exchange"); + exchangeCall.arg(getUrl(element, holder)); + exchangeCall.arg(getHttpMethod(holder)); + exchangeCall.arg(getRequestEntity(element, holder, methodBody, params)); + exchangeCall.arg(getResponseClass(element, holder)); + JExpression urlVariables = getUrlVariables(element, holder, methodBody, params); + if (urlVariables != null) + exchangeCall.arg(urlVariables); + + // Call exchange() + if (executableElement.getReturnType().getKind() == TypeKind.VOID) { + methodBody.add(exchangeCall); + } else { + exchangeCall = addResultCallMethod(exchangeCall, methodReturnClass); + methodBody._return(exchangeCall); + } + } + + protected JClass getMethodReturnClass(Element element, RestHolder holder) { + ExecutableElement executableElement = (ExecutableElement) element; + return codeModelHelper.typeMirrorToJClass(executableElement.getReturnType(), holder); + } + + protected TreeMap addMethodParams(ExecutableElement executableElement, RestHolder restHolder, JMethod method) { + List params = executableElement.getParameters(); + TreeMap methodParams = new TreeMap(); + for (VariableElement parameter : params) { + String paramName = parameter.getSimpleName().toString(); + String paramType = parameter.asType().toString(); + + JVar param; + if (parameter.asType().getKind().isPrimitive()) { + param = method.param(JType.parse(restHolder.codeModel(), paramType), paramName); + } else { + JClass parameterClass = codeModelHelper.typeMirrorToJClass(parameter.asType(), restHolder); + param = method.param(parameterClass, paramName); + } + methodParams.put(paramName, param); + } + return methodParams; + } + + protected JExpression getUrl(Element element, RestHolder restHolder) { + return JExpr.invoke(restHolder.getRootUrlField(), "concat").arg(JExpr.lit(getUrlSuffix(element))); + } + + protected abstract String getUrlSuffix(Element element); + + protected JExpression getHttpMethod(RestHolder holder) { + JClass httpMethod = holder.classes().HTTP_METHOD; + String simpleName = getTarget().substring(getTarget().lastIndexOf('.') + 1); + String restMethodInCapitalLetters = simpleName.toUpperCase(Locale.ENGLISH); + return httpMethod.staticRef(restMethodInCapitalLetters); + } + + protected JExpression getRequestEntity(Element element, RestHolder restHolder, JBlock methodBody, TreeMap params) { + return JExpr._null(); + } + + protected JExpression getResponseClass(Element element, RestHolder holder) { + return JExpr._null(); + } + + protected JExpression getUrlVariables(Element element, RestHolder holder, JBlock methodBody, TreeMap params) { + return restAnnotationHelper.declareUrlVariables((ExecutableElement) element, holder, methodBody, params); + } + + protected JInvocation addResultCallMethod(JInvocation exchangeCall, JClass methodReturnClass) { + return exchangeCall; + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/RestAnnotationHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/RestAnnotationHelper.java index be00303100..17a0c871e0 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/RestAnnotationHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/RestAnnotationHelper.java @@ -15,21 +15,22 @@ */ package org.androidannotations.helper; -import java.util.ArrayList; -import java.util.HashSet; -import java.util.List; -import java.util.Set; -import java.util.regex.Matcher; -import java.util.regex.Pattern; +import com.sun.codemodel.*; +import org.androidannotations.annotations.rest.Accept; +import org.androidannotations.holder.RestHolder; +import org.androidannotations.validation.IsValid; import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.VariableElement; - -import org.androidannotations.validation.IsValid; +import javax.lang.model.element.*; +import javax.lang.model.type.*; +import java.util.*; +import java.util.regex.Matcher; +import java.util.regex.Pattern; public class RestAnnotationHelper extends TargetAnnotationHelper { + private APTCodeModelHelper codeModelHelper = new APTCodeModelHelper(); + public RestAnnotationHelper(ProcessingEnvironment processingEnv, String annotationName) { super(processingEnv, annotationName); } @@ -87,14 +88,6 @@ public void urlVariableNamesExistInParametersAndHasOnlyOneMoreParameter(Executab public Set extractUrlVariableNames(ExecutableElement element) { - // extract variables name from root url isn't really useful - - // Element enclosingElement = element.getEnclosingElement(); - // String urlPrefix = - // enclosingElement.getAnnotation(Rest.class).value(); - // String urlSuffix = extractAnnotationValue(element); - // String uriTemplate = urlPrefix + urlSuffix; - Set variableNames = new HashSet(); String uriTemplate = extractAnnotationValueParameter(element); @@ -109,4 +102,238 @@ public Set extractUrlVariableNames(ExecutableElement element) { return variableNames; } + public JVar declareUrlVariables(ExecutableElement element, RestHolder holder, JBlock methodBody, TreeMap methodParams) { + Set urlVariables = extractUrlVariableNames(element); + JClass hashMapClass = holder.refClass(HashMap.class).narrow(String.class, Object.class); + if (!urlVariables.isEmpty()) { + JVar hashMapVar = methodBody.decl(hashMapClass, "urlVariables", JExpr._new(hashMapClass)); + for (String urlVariable : urlVariables) { + JVar urlValue = methodParams.get(urlVariable); + methodBody.invoke(hashMapVar, "put").arg(urlVariable).arg(urlValue); + methodParams.remove(urlVariable); + } + return hashMapVar; + } + return null; + } + + public String acceptedHeaders(ExecutableElement executableElement) { + Accept acceptAnnotation = executableElement.getAnnotation(Accept.class); + if (acceptAnnotation == null) { + acceptAnnotation = executableElement.getEnclosingElement().getAnnotation(Accept.class); + } + if (acceptAnnotation != null) { + return acceptAnnotation.value(); + } else { + return null; + } + } + + public JVar declareAcceptedHttpHeaders(RestHolder holder, JBlock body, String mediaType) { + JClass httpHeadersClass = holder.classes().HTTP_HEADERS; + JClass collectionsClass = holder.classes().COLLECTIONS; + JClass mediaTypeClass = holder.classes().MEDIA_TYPE; + + JVar httpHeadersVar = body.decl(httpHeadersClass, "httpHeaders", JExpr._new(httpHeadersClass)); + JInvocation mediaTypeListParam = collectionsClass.staticInvoke("singletonList").arg(mediaTypeClass.staticInvoke("parseMediaType").arg(mediaType)); + body.add(JExpr.invoke(httpHeadersVar, "setAccept").arg(mediaTypeListParam)); + + return httpHeadersVar; + } + + public JExpression declareHttpEntity(RestHolder holder, JBlock body, TreeMap methodParams) { + return declareHttpEntity(holder, body, methodParams, null); + } + + public JExpression declareHttpEntity(RestHolder holder, JBlock body, TreeMap methodParams, JVar httpHeaders) { + JVar entitySentToServer = null; + JType entityType = holder.refClass(Object.class); + + if (!methodParams.isEmpty()) { + entitySentToServer = methodParams.firstEntry().getValue(); + entityType = entitySentToServer.type(); + if (entityType.isPrimitive()) { + // Don't narrow primitive types... + entityType = entityType.boxify(); + } + } + + JClass httpEntity = holder.classes().HTTP_ENTITY; + JClass narrowedHttpEntity = httpEntity.narrow(entityType); + JInvocation newHttpEntityVarCall = JExpr._new(narrowedHttpEntity); + + if (entitySentToServer != null) { + newHttpEntityVarCall.arg(entitySentToServer); + } + + if (httpHeaders != null) { + newHttpEntityVarCall.arg(httpHeaders); + } else if (entitySentToServer == null) { + newHttpEntityVarCall.arg(JExpr._null()); + } + + return body.decl(narrowedHttpEntity, "requestEntity", newHttpEntityVarCall); + } + + public JExpression getResponseClass(Element element, RestHolder holder) { + ExecutableElement executableElement = (ExecutableElement) element; + JExpression responseClassExpr = JExpr._null(); + TypeMirror returnType = executableElement.getReturnType(); + if (returnType.getKind() != TypeKind.VOID) { + JClass responseClass = retrieveResponseClass(returnType, holder); + if (responseClass != null) { + responseClassExpr = responseClass.dotclass(); + } + } + return responseClassExpr; + } + + public JClass retrieveResponseClass(TypeMirror returnType, RestHolder holder) { + String returnTypeString = returnType.toString(); + + JClass responseClass; + + if (returnTypeString.startsWith(CanonicalNameConstants.RESPONSE_ENTITY)) { + DeclaredType declaredReturnType = (DeclaredType) returnType; + if (declaredReturnType.getTypeArguments().size() > 0) { + responseClass = resolveResponseClass(declaredReturnType.getTypeArguments().get(0), holder); + } else { + responseClass = holder.classes().RESPONSE_ENTITY; + } + } else { + responseClass = resolveResponseClass(returnType, holder); + } + + return responseClass; + } + + /** + * Resolve the expected class for the input type according to the following + * rules : + *
    + *
  • The type is a primitive : Directly return the JClass as usual
    • + *
  • The type is NOT a generics : Directly return the JClass as usual
    • + *
  • The type is a generics and enclosing type is a class C<T> : + * Generate a subclass of C<T> and return it
    • + *
  • The type is a generics and enclosing type is an interface I<T> + * : Looking the inheritance tree, then
    • + *
      + *
    1. One of the parent is a {@link Map} : Generate a subclass of + * {@link LinkedHashMap}<T> one and return it
      2. + *
    2. One of the parent is a {@link Set} : Generate a subclass of + * {@link TreeSet}<T> one and return it
      3. + *
    3. One of the parent is a {@link Collection} : Generate a subclass of + * {@link ArrayList}<T> one and return it
      4. + *
    4. Return {@link Object} definition
      5. + *
    + *
+ * + */ + private JClass resolveResponseClass(TypeMirror expectedType, RestHolder holder) { + // is a class or an interface + if (expectedType.getKind() == TypeKind.DECLARED) { + DeclaredType declaredType = (DeclaredType) expectedType; + + List typeArguments = declaredType.getTypeArguments(); + + // is NOT a generics, return directly + if (typeArguments.isEmpty()) { + return codeModelHelper.typeMirrorToJClass(declaredType, holder); + } + + // is a generics, must generate a new super class + TypeElement declaredElement = (TypeElement) declaredType.asElement(); + + JClass baseClass = codeModelHelper.typeMirrorToJClass(declaredType, holder).erasure(); + JClass decoratedExpectedClass = retrieveDecoratedResponseClass(declaredType, declaredElement, holder); + if (decoratedExpectedClass == null) { + decoratedExpectedClass = baseClass; + } + return decoratedExpectedClass; + } else if (expectedType.getKind() == TypeKind.ARRAY) { + ArrayType arrayType = (ArrayType) expectedType; + return resolveResponseClass(arrayType.getComponentType(), holder).array(); + } + + // is not a class nor an interface, return directly + return codeModelHelper.typeMirrorToJClass(expectedType, holder); + } + + /** + * Recursive method used to find if one of the grand-parent of the + * enclosingJClass is {@link Map}, {@link Set} or + * {@link Collection}. + */ + private JClass retrieveDecoratedResponseClass(DeclaredType declaredType, TypeElement typeElement, RestHolder holder) { + String classTypeBaseName = typeElement.toString(); + + // Looking for basic java.util interfaces to set a default + // implementation + String decoratedClassName = null; + + if (typeElement.getKind() == ElementKind.INTERFACE) { + if (classTypeBaseName.equals(CanonicalNameConstants.MAP)) { + decoratedClassName = LinkedHashMap.class.getCanonicalName(); + } else if (classTypeBaseName.equals(CanonicalNameConstants.SET)) { + decoratedClassName = TreeSet.class.getCanonicalName(); + } else if (classTypeBaseName.equals(CanonicalNameConstants.LIST)) { + decoratedClassName = ArrayList.class.getCanonicalName(); + } else if (classTypeBaseName.equals(CanonicalNameConstants.COLLECTION)) { + decoratedClassName = ArrayList.class.getCanonicalName(); + } + } else { + decoratedClassName = typeElement.getQualifiedName().toString(); + } + + if (decoratedClassName != null) { + // Configure the super class of the final decorated class + String decoratedClassNameSuffix = ""; + JClass decoratedSuperClass = holder.refClass(decoratedClassName); + for (TypeMirror typeArgument : declaredType.getTypeArguments()) { + if (typeArgument instanceof WildcardType) { + WildcardType wildcardType = (WildcardType) typeArgument; + if (wildcardType.getExtendsBound() != null) { + typeArgument = wildcardType.getExtendsBound(); + } else if (wildcardType.getSuperBound() != null) { + typeArgument = wildcardType.getSuperBound(); + } + } + JClass narrowJClass = codeModelHelper.typeMirrorToJClass(typeArgument, holder); + decoratedSuperClass = decoratedSuperClass.narrow(narrowJClass); + decoratedClassNameSuffix += plainName(narrowJClass); + } + + String decoratedFinalClassName = classTypeBaseName + "_" + decoratedClassNameSuffix; + decoratedFinalClassName = decoratedFinalClassName.replaceAll("\\[\\]", "s"); + String packageName = holder.getGeneratedClass()._package().name(); + decoratedFinalClassName = packageName + "." + decoratedFinalClassName; + JDefinedClass decoratedJClass = holder.definedClass(decoratedFinalClassName); + decoratedJClass._extends(decoratedSuperClass); + + return decoratedJClass; + } + + // Try to find the superclass and make a recursive call to the this + // method + TypeMirror enclosingSuperJClass = typeElement.getSuperclass(); + if (enclosingSuperJClass != null && enclosingSuperJClass.getKind() == TypeKind.DECLARED) { + DeclaredType declaredEnclosingSuperJClass = (DeclaredType) enclosingSuperJClass; + return retrieveDecoratedResponseClass(declaredType, (TypeElement) declaredEnclosingSuperJClass.asElement(), holder); + } + + // Falling back to the current enclosingJClass if Class can't be found + return null; + } + + protected String plainName(JClass jClass) { + String plainName = jClass.erasure().name(); + List typeParameters = jClass.getTypeParameters(); + if (typeParameters.size() > 0) { + plainName += "_"; + for (JClass typeParameter : typeParameters) { + plainName += plainName(typeParameter); + } + } + return plainName; + } } From 6667c428ac5f4616a17bceffa37fef3f6af89370 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Mon, 3 Jun 2013 15:53:32 +0200 Subject: [PATCH 35/86] Implement GetHandler --- .../handler/AnnotationHandlers.java | 2 + .../handler/rest/GetHandler.java | 66 +++++++++++++++++++ 2 files changed, 68 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/GetHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index ef65f32335..066b8e43f7 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -1,5 +1,6 @@ package org.androidannotations.handler; +import org.androidannotations.handler.rest.GetHandler; import org.androidannotations.handler.rest.RestHandler; import org.androidannotations.helper.AndroidManifest; import org.androidannotations.holder.GeneratedClassHolder; @@ -52,6 +53,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new FragmentArgHandler(processingEnvironment)); add(new SystemServiceHandler(processingEnvironment)); add(new RestHandler(processingEnvironment)); + add(new GetHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/GetHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/GetHandler.java new file mode 100644 index 0000000000..537b23ab84 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/GetHandler.java @@ -0,0 +1,66 @@ +package org.androidannotations.handler.rest; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.rest.Get; +import org.androidannotations.helper.CanonicalNameConstants; +import org.androidannotations.holder.RestHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; +import java.util.TreeMap; + +public class GetHandler extends RestMethodHandler { + + public GetHandler(ProcessingEnvironment processingEnvironment) { + super(Get.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + if (!super.validate(element, validatedElements)) { + valid.invalidate(); + } + + validatorHelper.doesNotReturnPrimitive((ExecutableElement) element, valid); + + restAnnotationHelper.urlVariableNamesExistInParametersAndHasNoOneMoreParameter((ExecutableElement) element, valid); + + return valid.isValid(); + } + + @Override + protected String getUrlSuffix(Element element) { + Get annotation = element.getAnnotation(Get.class); + return annotation.value(); + } + + @Override + protected JExpression getRequestEntity(Element element, RestHolder holder, JBlock methodBody, TreeMap methodParams) { + ExecutableElement executableElement = (ExecutableElement) element; + String mediaType = restAnnotationHelper.acceptedHeaders(executableElement); + if (mediaType != null) { + JClass httpEntity = holder.classes().HTTP_ENTITY; + JInvocation newHttpEntityVarCall = JExpr._new(httpEntity.narrow(Object.class)); + JVar httpHeaders = restAnnotationHelper.declareAcceptedHttpHeaders(holder, methodBody, mediaType); + newHttpEntityVarCall.arg(httpHeaders); + return methodBody.decl(httpEntity.narrow(Object.class), "requestEntity", newHttpEntityVarCall); + } + return JExpr._null(); + } + + protected JExpression getResponseClass(Element element, RestHolder holder) { + return restAnnotationHelper.getResponseClass(element, holder); + } + + protected JInvocation addResultCallMethod(JInvocation exchangeCall, JClass methodReturnClass) { + if (methodReturnClass != null && !methodReturnClass.fullName().startsWith(CanonicalNameConstants.RESPONSE_ENTITY)) { + return JExpr.invoke(exchangeCall, "getBody"); + } + return exchangeCall; + } +} From be221e6caf5a9d3d8159ce3812e2e06f6d2b6f62 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Mon, 3 Jun 2013 16:08:21 +0200 Subject: [PATCH 36/86] Implement PostHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/PostHandler.java | 62 +++++++++++++++++++ 2 files changed, 63 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PostHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 066b8e43f7..af119d62d3 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -54,6 +54,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new SystemServiceHandler(processingEnvironment)); add(new RestHandler(processingEnvironment)); add(new GetHandler(processingEnvironment)); + add(new PostHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PostHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PostHandler.java new file mode 100644 index 0000000000..34a12b8d01 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PostHandler.java @@ -0,0 +1,62 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.rest.Post; +import org.androidannotations.helper.CanonicalNameConstants; +import org.androidannotations.holder.RestHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; +import java.util.TreeMap; + +public class PostHandler extends RestMethodHandler { + + public PostHandler(ProcessingEnvironment processingEnvironment) { + super(Post.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + if (!super.validate(element, validatedElements)) { + valid.invalidate(); + } + + validatorHelper.doesNotReturnPrimitive((ExecutableElement) element, valid); + + restAnnotationHelper.urlVariableNamesExistInParametersAndHasOnlyOneMoreParameter((ExecutableElement) element, valid); + + return valid.isValid(); + } + + @Override + protected String getUrlSuffix(Element element) { + Post annotation = element.getAnnotation(Post.class); + return annotation.value(); + } + + @Override + protected JExpression getRequestEntity(Element element, RestHolder holder, JBlock methodBody, TreeMap methodParams) { + String mediaType = restAnnotationHelper.acceptedHeaders((ExecutableElement) element); + JVar httpRestHeaders = null; + if (mediaType != null) { + httpRestHeaders = restAnnotationHelper.declareAcceptedHttpHeaders(holder, methodBody, mediaType); + } + return restAnnotationHelper.declareHttpEntity(holder, methodBody, methodParams, httpRestHeaders); + } + + protected JExpression getResponseClass(Element element, RestHolder holder) { + return restAnnotationHelper.getResponseClass(element, holder); + } + + protected JInvocation addResultCallMethod(JInvocation exchangeCall, JClass methodReturnClass) { + if (methodReturnClass != null && !methodReturnClass.fullName().startsWith(CanonicalNameConstants.RESPONSE_ENTITY)) { + return JExpr.invoke(exchangeCall, "getBody"); + } + return exchangeCall; + } +} From d6a646edbf1703d89de291e772bb037d43c4d133 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Mon, 3 Jun 2013 16:17:20 +0200 Subject: [PATCH 37/86] Implement PutHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/PutHandler.java | 48 +++++++++++++++++++ 2 files changed, 49 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PutHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index af119d62d3..2183e51168 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -55,6 +55,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new RestHandler(processingEnvironment)); add(new GetHandler(processingEnvironment)); add(new PostHandler(processingEnvironment)); + add(new PutHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PutHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PutHandler.java new file mode 100644 index 0000000000..9706c3fb2f --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PutHandler.java @@ -0,0 +1,48 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JVar; +import org.androidannotations.annotations.rest.Put; +import org.androidannotations.handler.rest.RestMethodHandler; +import org.androidannotations.holder.RestHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; +import java.util.TreeMap; + +public class PutHandler extends RestMethodHandler { + + public PutHandler(ProcessingEnvironment processingEnvironment) { + super(Put.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + if (!super.validate(element, validatedElements)) { + valid.invalidate(); + } + + validatorHelper.returnTypeIsVoid((ExecutableElement) element, valid); + + restAnnotationHelper.urlVariableNamesExistInParametersAndHasOnlyOneMoreParameter((ExecutableElement) element, valid); + + return valid.isValid(); + } + + @Override + protected String getUrlSuffix(Element element) { + Put annotation = element.getAnnotation(Put.class); + return annotation.value(); + } + + @Override + protected JExpression getRequestEntity(Element element, RestHolder holder, JBlock methodBody, TreeMap methodParams) { + return restAnnotationHelper.declareHttpEntity(holder, methodBody, methodParams); + } +} From 1ca9dccb3695ff2b21116788e8e4bba73e486a66 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Mon, 3 Jun 2013 16:23:21 +0200 Subject: [PATCH 38/86] Implement DeleteHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/DeleteHandler.java | 38 +++++++++++++++++++ 2 files changed, 39 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/DeleteHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 2183e51168..951b6d77d0 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -56,6 +56,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new GetHandler(processingEnvironment)); add(new PostHandler(processingEnvironment)); add(new PutHandler(processingEnvironment)); + add(new DeleteHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/DeleteHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/DeleteHandler.java new file mode 100644 index 0000000000..b46ee8724d --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/DeleteHandler.java @@ -0,0 +1,38 @@ +package org.androidannotations.handler; + +import org.androidannotations.annotations.rest.Delete; +import org.androidannotations.handler.rest.RestMethodHandler; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; + +public class DeleteHandler extends RestMethodHandler { + + public DeleteHandler(ProcessingEnvironment processingEnvironment) { + super(Delete.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + if (!super.validate(element, validatedElements)) { + valid.invalidate(); + } + + validatorHelper.returnTypeIsVoid((ExecutableElement) element, valid); + + restAnnotationHelper.urlVariableNamesExistInParametersAndHasNoOneMoreParameter((ExecutableElement) element, valid); + + return valid.isValid(); + } + + @Override + protected String getUrlSuffix(Element element) { + Delete annotation = element.getAnnotation(Delete.class); + return annotation.value(); + } +} From 75513cc8b31369e56a25e329697eb7234f75b6aa Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Mon, 3 Jun 2013 16:29:19 +0200 Subject: [PATCH 39/86] Implement HeadHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/HeadHandler.java | 46 +++++++++++++++++++ 2 files changed, 47 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HeadHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 951b6d77d0..58ff162b8d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -57,6 +57,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new PostHandler(processingEnvironment)); add(new PutHandler(processingEnvironment)); add(new DeleteHandler(processingEnvironment)); + add(new HeadHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HeadHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HeadHandler.java new file mode 100644 index 0000000000..2c13c605d2 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HeadHandler.java @@ -0,0 +1,46 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JClass; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JInvocation; +import org.androidannotations.annotations.rest.Head; +import org.androidannotations.handler.rest.RestMethodHandler; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; + +public class HeadHandler extends RestMethodHandler { + + public HeadHandler(ProcessingEnvironment processingEnvironment) { + super(Head.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + if (!super.validate(element, validatedElements)) { + valid.invalidate(); + } + + validatorHelper.hasHttpHeadersReturnType((ExecutableElement) element, valid); + + restAnnotationHelper.urlVariableNamesExistInParametersAndHasNoOneMoreParameter((ExecutableElement) element, valid); + + return valid.isValid(); + } + + @Override + protected String getUrlSuffix(Element element) { + Head annotation = element.getAnnotation(Head.class); + return annotation.value(); + } + + @Override + protected JInvocation addResultCallMethod(JInvocation exchangeCall, JClass methodReturnClass) { + return JExpr.invoke(exchangeCall, "getHeaders"); + } +} From 1cad37999f2a8e16a36c03d7b477c81e7059a529 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Mon, 3 Jun 2013 16:41:07 +0200 Subject: [PATCH 40/86] Implement OptionsHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/OptionsHandler.java | 44 +++++++++++++++++++ 2 files changed, 45 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 58ff162b8d..355a8ae11a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -58,6 +58,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new PutHandler(processingEnvironment)); add(new DeleteHandler(processingEnvironment)); add(new HeadHandler(processingEnvironment)); + add(new OptionsHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsHandler.java new file mode 100644 index 0000000000..0b689ea854 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsHandler.java @@ -0,0 +1,44 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JClass; +import com.sun.codemodel.JInvocation; +import org.androidannotations.annotations.rest.Options; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; + +public class OptionsHandler extends RestMethodHandler { + + public OptionsHandler(ProcessingEnvironment processingEnvironment) { + super(Options.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + if (!super.validate(element, validatedElements)) { + valid.invalidate(); + } + + validatorHelper.hasSetOfHttpMethodReturnType((ExecutableElement) element, valid); + + restAnnotationHelper.urlVariableNamesExistInParametersAndHasNoOneMoreParameter((ExecutableElement) element, valid); + + return valid.isValid(); + } + + @Override + protected String getUrlSuffix(Element element) { + Options annotation = element.getAnnotation(Options.class); + return annotation.value(); + } + + @Override + protected JInvocation addResultCallMethod(JInvocation exchangeCall, JClass methodReturnClass) { + return exchangeCall.invoke("getHeaders").invoke("getAllow"); + } +} From d8af1f4ba1daae585de01b0ae5cdefaa004960ff Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Mon, 3 Jun 2013 16:54:12 +0200 Subject: [PATCH 41/86] Implement AppHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/AppHandler.java | 44 +++++++++++++++++++ 2 files changed, 45 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 355a8ae11a..619dec6b65 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -59,6 +59,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new DeleteHandler(processingEnvironment)); add(new HeadHandler(processingEnvironment)); add(new OptionsHandler(processingEnvironment)); + add(new AppHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java new file mode 100644 index 0000000000..cde053f666 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java @@ -0,0 +1,44 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JClass; +import org.androidannotations.annotations.App; +import org.androidannotations.annotations.EApplication; +import org.androidannotations.helper.ModelConstants; +import org.androidannotations.holder.EApplicationHolder; +import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + +import static com.sun.codemodel.JExpr.ref; + +public class AppHandler extends BaseAnnotationHandler { + + public AppHandler(ProcessingEnvironment processingEnvironment) { + super(App.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); + + validatorHelper.typeHasAnnotation(EApplication.class, element, valid); + + validatorHelper.isNotPrivate(element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EComponentHolder holder) { + String fieldName = element.getSimpleName().toString(); + String applicationQualifiedName = element.asType().toString(); + JClass applicationClass = holder.refClass(applicationQualifiedName + ModelConstants.GENERATION_SUFFIX); + + holder.getInit().body().assign(ref(fieldName), applicationClass.staticInvoke(EApplicationHolder.GET_APPLICATION_INSTANCE)); + } +} From 459dee7a78cef4ee35e56e4f3cc7f314ba91fcde Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Mon, 3 Jun 2013 17:25:22 +0200 Subject: [PATCH 42/86] Implement OptionsMenuHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/OptionsMenuHandler.java | 57 +++++++++++++++++++ .../helper/ThirdPartyLibHelper.java | 14 ++++- .../holder/EActivityHolder.java | 53 ++++++++++++++++- .../holder/EFragmentHolder.java | 54 +++++++++++++++++- .../holder/HasOptionsMenu.java | 10 ++++ 6 files changed, 185 insertions(+), 4 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOptionsMenu.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 619dec6b65..cfc9ab42e6 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -60,6 +60,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new HeadHandler(processingEnvironment)); add(new OptionsHandler(processingEnvironment)); add(new AppHandler(processingEnvironment)); + add(new OptionsMenuHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuHandler.java new file mode 100644 index 0000000000..932e33b49c --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuHandler.java @@ -0,0 +1,57 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JFieldRef; +import com.sun.codemodel.JVar; +import org.androidannotations.annotations.OptionsMenu; +import org.androidannotations.helper.AndroidManifest; +import org.androidannotations.helper.IdAnnotationHelper; +import org.androidannotations.helper.IdValidatorHelper; +import org.androidannotations.holder.HasOptionsMenu; +import org.androidannotations.model.AndroidSystemServices; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.rclass.IRClass; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import java.util.List; + +public class OptionsMenuHandler extends BaseAnnotationHandler { + + private IdAnnotationHelper annotationHelper; + + public OptionsMenuHandler(ProcessingEnvironment processingEnvironment) { + super(OptionsMenu.class, processingEnvironment); + } + + @Override + public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) { + super.setAndroidEnvironment(rClass, androidSystemServices, androidManifest); + annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.hasEActivityOrEFragment(element, validatedElements, valid); + + validatorHelper.resIdsExist(element, IRClass.Res.MENU, IdValidatorHelper.FallbackStrategy.NEED_RES_ID, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, HasOptionsMenu holder) { + JBlock body = holder.getOnCreateOptionsMenuMethodBody(); + JVar menuInflater = holder.getOnCreateOptionsMenuMenuInflaterVar(); + JVar menuParam = holder.getOnCreateOptionsMenuMenuParam(); + + List fieldRefs = annotationHelper.extractAnnotationFieldRefs(holder, element, IRClass.Res.MENU, false); + for (JFieldRef optionsMenuRefId : fieldRefs) { + body.invoke(menuInflater, "inflate").arg(optionsMenuRefId).arg(menuParam); + } + + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ThirdPartyLibHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ThirdPartyLibHelper.java index 899236b693..0c409fa271 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ThirdPartyLibHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ThirdPartyLibHelper.java @@ -15,13 +15,14 @@ */ package org.androidannotations.helper; +import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.processing.EBeanHolder; + import javax.lang.model.element.TypeElement; import javax.lang.model.type.DeclaredType; import javax.lang.model.type.NoType; import javax.lang.model.type.TypeMirror; -import org.androidannotations.processing.EBeanHolder; - public class ThirdPartyLibHelper { private final AnnotationHelper annotationHelper; @@ -57,6 +58,15 @@ public boolean usesActionBarSherlock(EBeanHolder holder) { return usesActionBarSherlock(typeElement); } + /** + * Checks whether the Activity extends one of the ActionBarSherlock Activity + * types + */ + public boolean usesActionBarSherlock(EComponentHolder holder) { + TypeElement typeElement = annotationHelper.typeElementFromQualifiedName(holder.getGeneratedClass()._extends().fullName()); + return usesActionBarSherlock(typeElement); + } + /** * Checks whether the Activity extends one of the ActionBarSherlock Activity * types diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java index 79762ed001..2f667484ed 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java @@ -18,7 +18,7 @@ import static com.sun.codemodel.JMod.PRIVATE; import static com.sun.codemodel.JMod.PUBLIC; -public class EActivityHolder extends EComponentHolder implements HasIntentBuilder, HasViewChanged, HasExtras, HasInstanceState { +public class EActivityHolder extends EComponentHolder implements HasIntentBuilder, HasViewChanged, HasExtras, HasInstanceState, HasOptionsMenu { private ViewNotifierHelper viewNotifierHelper; private GreenDroidHelper greenDroidHelper; @@ -38,6 +38,9 @@ public class EActivityHolder extends EComponentHolder implements HasIntentBuilde private JMethod injectExtrasMethod; private JBlock injectExtrasBlock; private JVar injectExtras; + private JBlock onCreateOptionsMenuMethodBody; + private JVar onCreateOptionsMenuMenuInflaterVar; + private JVar onCreateOptionsMenuMenuParam; public EActivityHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); @@ -188,6 +191,30 @@ protected void setOnActivityResult() { roboGuiceHolder.data = data; } + private void setOnCreateOptionsMenu() { + JClass menuClass = classes().MENU; + JClass menuInflaterClass = classes().MENU_INFLATER; + String getMenuInflaterMethodName = "getMenuInflater"; + if (usesActionBarSherlock()) { + menuClass = classes().SHERLOCK_MENU; + menuInflaterClass = classes().SHERLOCK_MENU_INFLATER; + getMenuInflaterMethodName = "getSupportMenuInflater"; + } + + + JMethod method = generatedClass.method(PUBLIC, codeModel().BOOLEAN, "onCreateOptionsMenu"); + method.annotate(Override.class); + JBlock methodBody = method.body(); + onCreateOptionsMenuMenuParam = method.param(menuClass, "menu"); + onCreateOptionsMenuMenuInflaterVar = methodBody.decl(menuInflaterClass, "menuInflater", invoke(getMenuInflaterMethodName)); + onCreateOptionsMenuMethodBody = methodBody.block(); + methodBody._return(_super().invoke(method).arg(onCreateOptionsMenuMenuParam)); + } + + private boolean usesActionBarSherlock() { + return new ThirdPartyLibHelper(new AnnotationHelper(processingEnvironment())).usesActionBarSherlock(this); + } + @Override public ViewChangedHolder getOnViewChangedHolder() { if (viewChangedHolder == null) { @@ -475,4 +502,28 @@ public JMethod getRestoreStateMethod() { public JVar getRestoreStateBundleParam() { return instanceStateHolder.getRestoreStateBundleParam(); } + + @Override + public JBlock getOnCreateOptionsMenuMethodBody() { + if (onCreateOptionsMenuMethodBody == null) { + setOnCreateOptionsMenu(); + } + return onCreateOptionsMenuMethodBody; + } + + @Override + public JVar getOnCreateOptionsMenuMenuInflaterVar() { + if (onCreateOptionsMenuMenuInflaterVar == null) { + setOnCreateOptionsMenu(); + } + return onCreateOptionsMenuMenuInflaterVar; + } + + @Override + public JVar getOnCreateOptionsMenuMenuParam() { + if (onCreateOptionsMenuMenuParam == null) { + setOnCreateOptionsMenu(); + } + return onCreateOptionsMenuMenuParam; + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java index 0cb77d3f35..3f2005f44e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java @@ -5,13 +5,14 @@ import org.androidannotations.helper.HoloEverywhereHelper; import org.androidannotations.helper.ViewNotifierHelper; import org.androidannotations.process.ProcessHolder; +import org.androidannotations.helper.*; import javax.lang.model.element.TypeElement; import static com.sun.codemodel.JExpr.*; import static com.sun.codemodel.JMod.*; -public class EFragmentHolder extends EComponentHolder implements HasViewChanged, HasInstanceState { +public class EFragmentHolder extends EComponentHolder implements HasViewChanged, HasInstanceState, HasOptionsMenu { private ViewNotifierHelper viewNotifierHelper; private JFieldVar contentView; @@ -29,6 +30,9 @@ public class EFragmentHolder extends EComponentHolder implements HasViewChanged, private JBlock injectArgsBlock; private JVar injectBundleArgs; private InstanceStateHolder instanceStateHolder; + private JBlock onCreateOptionsMenuMethodBody; + private JVar onCreateOptionsMenuMenuInflaterVar; + private JVar onCreateOptionsMenuMenuParam; public EFragmentHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); @@ -98,11 +102,35 @@ private void createFragmentBuilderBuild() { body.invoke(fragment, "setArguments").arg(fragmentArgumentsBuilderField); body._return(fragment); } + private void createFragmentBuilderCreate() { JMethod method = generatedClass.method(STATIC | PUBLIC, fragmentBuilderClass, "builder"); method.body()._return(_new(fragmentBuilderClass)); } + private void setOnCreateOptionsMenu() { + JClass menuClass = classes().MENU; + JClass menuInflaterClass = classes().MENU_INFLATER; + if (usesActionBarSherlock()) { + menuClass = classes().SHERLOCK_MENU; + menuInflaterClass = classes().SHERLOCK_MENU_INFLATER; + } + + JMethod method = generatedClass.method(PUBLIC, codeModel().VOID, "onCreateOptionsMenu"); + method.annotate(Override.class); + JBlock methodBody = method.body(); + onCreateOptionsMenuMenuParam = method.param(menuClass, "menu"); + onCreateOptionsMenuMenuInflaterVar = method.param(menuInflaterClass, "inflater"); + onCreateOptionsMenuMethodBody = methodBody.block(); + methodBody.invoke(_super(), method).arg(onCreateOptionsMenuMenuParam).arg(onCreateOptionsMenuMenuInflaterVar); + + getInit().body().invoke("setHasOptionsMenu").arg(JExpr.TRUE); + } + + private boolean usesActionBarSherlock() { + return new ThirdPartyLibHelper(new AnnotationHelper(processingEnvironment())).usesActionBarSherlock(this); + } + @Override protected void setContextRef() { contextRef = JExpr.invoke("getActivity"); @@ -289,4 +317,28 @@ public JMethod getRestoreStateMethod() { public JVar getRestoreStateBundleParam() { return instanceStateHolder.getRestoreStateBundleParam(); } + + @Override + public JBlock getOnCreateOptionsMenuMethodBody() { + if (onCreateOptionsMenuMethodBody == null) { + setOnCreateOptionsMenu(); + } + return onCreateOptionsMenuMethodBody; + } + + @Override + public JVar getOnCreateOptionsMenuMenuInflaterVar() { + if (onCreateOptionsMenuMenuInflaterVar == null) { + setOnCreateOptionsMenu(); + } + return onCreateOptionsMenuMenuInflaterVar; + } + + @Override + public JVar getOnCreateOptionsMenuMenuParam() { + if (onCreateOptionsMenuMenuParam == null) { + setOnCreateOptionsMenu(); + } + return onCreateOptionsMenuMenuParam; + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOptionsMenu.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOptionsMenu.java new file mode 100644 index 0000000000..3c895b1c49 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOptionsMenu.java @@ -0,0 +1,10 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JVar; + +public interface HasOptionsMenu extends GeneratedClassHolder { + JBlock getOnCreateOptionsMenuMethodBody(); + JVar getOnCreateOptionsMenuMenuInflaterVar(); + JVar getOnCreateOptionsMenuMenuParam(); +} From 665f18523b991628c5665826aa747e302c57343a Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Mon, 3 Jun 2013 17:50:47 +0200 Subject: [PATCH 43/86] Implement OptionsMenuItemHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/OptionsMenuItemHandler.java | 61 +++++++++++++++++++ 2 files changed, 62 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuItemHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index cfc9ab42e6..9552406564 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -61,6 +61,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new OptionsHandler(processingEnvironment)); add(new AppHandler(processingEnvironment)); add(new OptionsMenuHandler(processingEnvironment)); + add(new OptionsMenuItemHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuItemHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuItemHandler.java new file mode 100644 index 0000000000..f12a2aebed --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuItemHandler.java @@ -0,0 +1,61 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JFieldRef; +import com.sun.codemodel.JVar; +import org.androidannotations.annotations.OptionsMenuItem; +import org.androidannotations.helper.AndroidManifest; +import org.androidannotations.helper.IdAnnotationHelper; +import org.androidannotations.helper.IdValidatorHelper; +import org.androidannotations.holder.HasOptionsMenu; +import org.androidannotations.model.AndroidSystemServices; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.rclass.IRClass; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + +import static com.sun.codemodel.JExpr.ref; + +public class OptionsMenuItemHandler extends BaseAnnotationHandler { + + private IdAnnotationHelper annotationHelper; + + public OptionsMenuItemHandler(ProcessingEnvironment processingEnvironment) { + super(OptionsMenuItem.class, processingEnvironment); + } + + @Override + public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) { + super.setAndroidEnvironment(rClass, androidSystemServices, androidManifest); + annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEActivityOrEFragment(element, validatedElements, valid); + + validatorHelper.isDeclaredType(element, valid); + + validatorHelper.extendsMenuItem(element, valid); + + validatorHelper.resIdsExist(element, IRClass.Res.ID, IdValidatorHelper.FallbackStrategy.USE_ELEMENT_NAME, valid); + + validatorHelper.isNotPrivate(element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, HasOptionsMenu holder) { + String fieldName = element.getSimpleName().toString(); + JBlock body = holder.getOnCreateOptionsMenuMethodBody(); + JVar menuParam = holder.getOnCreateOptionsMenuMenuParam(); + + JFieldRef idsRef = annotationHelper.extractOneAnnotationFieldRef(holder, element, IRClass.Res.ID, true); + body.assign(ref(fieldName), menuParam.invoke("findItem").arg(idsRef)); + } +} From fb11534e01c9c5a7b398a8e620ca064164c2606a Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Mon, 3 Jun 2013 17:59:37 +0200 Subject: [PATCH 44/86] Implement OptionsItemHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/OptionsItemHandler.java | 96 +++++++++++++++++++ .../holder/EActivityHolder.java | 44 +++++++++ .../holder/EFragmentHolder.java | 44 +++++++++ .../holder/HasOptionsMenu.java | 4 + 5 files changed, 189 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsItemHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 9552406564..fb777228be 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -62,6 +62,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new AppHandler(processingEnvironment)); add(new OptionsMenuHandler(processingEnvironment)); add(new OptionsMenuItemHandler(processingEnvironment)); + add(new OptionsItemHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsItemHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsItemHandler.java new file mode 100644 index 0000000000..7cce5cd930 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsItemHandler.java @@ -0,0 +1,96 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JFieldRef; +import com.sun.codemodel.JInvocation; +import org.androidannotations.annotations.OptionsItem; +import org.androidannotations.helper.AndroidManifest; +import org.androidannotations.helper.IdAnnotationHelper; +import org.androidannotations.helper.IdValidatorHelper; +import org.androidannotations.holder.HasOptionsMenu; +import org.androidannotations.model.AndroidSystemServices; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.rclass.IRClass; +import org.androidannotations.validation.IsValid; + +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 java.util.List; + +import static com.sun.codemodel.JExpr.TRUE; +import static com.sun.codemodel.JExpr.invoke; + +public class OptionsItemHandler extends BaseAnnotationHandler { + + private IdAnnotationHelper annotationHelper; + + public OptionsItemHandler(ProcessingEnvironment processingEnvironment) { + super(OptionsItem.class, processingEnvironment); + } + + @Override + public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) { + super.setAndroidEnvironment(rClass, androidSystemServices, androidManifest); + annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEActivityOrEFragment(element, validatedElements, valid); + + validatorHelper.resIdsExist(element, IRClass.Res.ID, IdValidatorHelper.FallbackStrategy.USE_ELEMENT_NAME, valid); + + validatorHelper.isNotPrivate(element, valid); + + validatorHelper.doesntThrowException(element, valid); + + validatorHelper.uniqueId(element, validatedElements, valid); + + ExecutableElement executableElement = (ExecutableElement) element; + + validatorHelper.returnTypeIsVoidOrBoolean(executableElement, valid); + + validatorHelper.param.zeroOrOneMenuItemParameter(executableElement, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, HasOptionsMenu holder) { + String methodName = element.getSimpleName().toString(); + + ExecutableElement executableElement = (ExecutableElement) element; + List parameters = executableElement.getParameters(); + TypeMirror returnType = executableElement.getReturnType(); + boolean returnMethodResult = returnType.getKind() != TypeKind.VOID; + + boolean hasItemParameter = parameters.size() == 1; + + List idsRefs = annotationHelper.extractAnnotationFieldRefs(holder, element, IRClass.Res.ID, true); + JExpression ifExpr = holder.getOnOptionsItemSelectedItemId().eq(idsRefs.get(0)); + for (int i = 1; i < idsRefs.size(); i++) { + ifExpr = ifExpr.cor(holder.getOnOptionsItemSelectedItemId().eq(idsRefs.get(i))); + } + + JBlock itemIfBody = holder.getOnOptionsItemSelectedIfElseBlock()._if(ifExpr)._then(); + JInvocation methodCall = invoke(methodName); + + if (returnMethodResult) { + itemIfBody._return(methodCall); + } else { + itemIfBody.add(methodCall); + itemIfBody._return(TRUE); + } + + if (hasItemParameter) { + methodCall.arg(holder.getOnOptionsItemSelectedItem()); + } + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java index 2f667484ed..b086bd07ca 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java @@ -41,6 +41,9 @@ public class EActivityHolder extends EComponentHolder implements HasIntentBuilde private JBlock onCreateOptionsMenuMethodBody; private JVar onCreateOptionsMenuMenuInflaterVar; private JVar onCreateOptionsMenuMenuParam; + private JVar onOptionsItemSelectedItem; + private JVar onOptionsItemSelectedItemId; + private JBlock onOptionsItemSelectedIfElseBlock; public EActivityHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); @@ -211,6 +214,23 @@ private void setOnCreateOptionsMenu() { methodBody._return(_super().invoke(method).arg(onCreateOptionsMenuMenuParam)); } + private void setOnOptionsItemSelected() { + JClass menuItemClass = classes().MENU_ITEM; + if (usesActionBarSherlock()) { + menuItemClass = classes().SHERLOCK_MENU_ITEM; + } + + JMethod method = generatedClass.method(JMod.PUBLIC, codeModel().BOOLEAN, "onOptionsItemSelected"); + method.annotate(Override.class); + JBlock methodBody = method.body(); + onOptionsItemSelectedItem = method.param(menuItemClass, "item"); + JVar handled = methodBody.decl(codeModel().BOOLEAN, "handled", invoke(_super(), method).arg(onOptionsItemSelectedItem)); + methodBody._if(handled)._then()._return(TRUE); + onOptionsItemSelectedItemId = methodBody.decl(codeModel().INT, "itemId_", onOptionsItemSelectedItem.invoke("getItemId")); + onOptionsItemSelectedIfElseBlock = methodBody.block(); + methodBody._return(FALSE); + } + private boolean usesActionBarSherlock() { return new ThirdPartyLibHelper(new AnnotationHelper(processingEnvironment())).usesActionBarSherlock(this); } @@ -526,4 +546,28 @@ public JVar getOnCreateOptionsMenuMenuParam() { } return onCreateOptionsMenuMenuParam; } + + @Override + public JVar getOnOptionsItemSelectedItem() { + if (onOptionsItemSelectedItem == null) { + setOnOptionsItemSelected(); + } + return onOptionsItemSelectedItem; + } + + @Override + public JVar getOnOptionsItemSelectedItemId() { + if (onOptionsItemSelectedItemId == null) { + setOnOptionsItemSelected(); + } + return onOptionsItemSelectedItemId; + } + + @Override + public JBlock getOnOptionsItemSelectedIfElseBlock() { + if (onOptionsItemSelectedIfElseBlock == null) { + setOnOptionsItemSelected(); + } + return onOptionsItemSelectedIfElseBlock; + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java index 3f2005f44e..c8e6e1aefc 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java @@ -33,6 +33,9 @@ public class EFragmentHolder extends EComponentHolder implements HasViewChanged, private JBlock onCreateOptionsMenuMethodBody; private JVar onCreateOptionsMenuMenuInflaterVar; private JVar onCreateOptionsMenuMenuParam; + private JVar onOptionsItemSelectedItem; + private JVar onOptionsItemSelectedItemId; + private JBlock onOptionsItemSelectedIfElseBlock; public EFragmentHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); @@ -127,6 +130,23 @@ private void setOnCreateOptionsMenu() { getInit().body().invoke("setHasOptionsMenu").arg(JExpr.TRUE); } + private void setOnOptionsItemSelected() { + JClass menuItemClass = classes().MENU_ITEM; + if (usesActionBarSherlock()) { + menuItemClass = classes().SHERLOCK_MENU_ITEM; + } + + JMethod method = generatedClass.method(JMod.PUBLIC, codeModel().BOOLEAN, "onOptionsItemSelected"); + method.annotate(Override.class); + JBlock methodBody = method.body(); + onOptionsItemSelectedItem = method.param(menuItemClass, "item"); + JVar handled = methodBody.decl(codeModel().BOOLEAN, "handled", invoke(_super(), method).arg(onOptionsItemSelectedItem)); + methodBody._if(handled)._then()._return(TRUE); + onOptionsItemSelectedItemId = methodBody.decl(codeModel().INT, "itemId_", onOptionsItemSelectedItem.invoke("getItemId")); + onOptionsItemSelectedIfElseBlock = methodBody.block(); + methodBody._return(FALSE); + } + private boolean usesActionBarSherlock() { return new ThirdPartyLibHelper(new AnnotationHelper(processingEnvironment())).usesActionBarSherlock(this); } @@ -341,4 +361,28 @@ public JVar getOnCreateOptionsMenuMenuParam() { } return onCreateOptionsMenuMenuParam; } + + @Override + public JVar getOnOptionsItemSelectedItem() { + if (onOptionsItemSelectedItem == null) { + setOnOptionsItemSelected(); + } + return onOptionsItemSelectedItem; + } + + @Override + public JVar getOnOptionsItemSelectedItemId() { + if (onOptionsItemSelectedItemId == null) { + setOnOptionsItemSelected(); + } + return onOptionsItemSelectedItemId; + } + + @Override + public JBlock getOnOptionsItemSelectedIfElseBlock() { + if (onOptionsItemSelectedIfElseBlock == null) { + setOnOptionsItemSelected(); + } + return onOptionsItemSelectedIfElseBlock; + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOptionsMenu.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOptionsMenu.java index 3c895b1c49..a9e287a724 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOptionsMenu.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOptionsMenu.java @@ -7,4 +7,8 @@ public interface HasOptionsMenu extends GeneratedClassHolder { JBlock getOnCreateOptionsMenuMethodBody(); JVar getOnCreateOptionsMenuMenuInflaterVar(); JVar getOnCreateOptionsMenuMenuParam(); + + JVar getOnOptionsItemSelectedItem(); + JVar getOnOptionsItemSelectedItemId(); + JBlock getOnOptionsItemSelectedIfElseBlock(); } From 663b944864faa908cd9475ed3504d67b703e9afa Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Mon, 3 Jun 2013 22:23:27 +0200 Subject: [PATCH 45/86] Implement NoTitleHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/NoTitleHandler.java | 33 +++++++++++++++++++ 2 files changed, 34 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index fb777228be..6b19424669 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -63,6 +63,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new OptionsMenuHandler(processingEnvironment)); add(new OptionsMenuItemHandler(processingEnvironment)); add(new OptionsItemHandler(processingEnvironment)); + add(new NoTitleHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java new file mode 100644 index 0000000000..084acefe9a --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java @@ -0,0 +1,33 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JFieldRef; +import org.androidannotations.annotations.NoTitle; +import org.androidannotations.holder.EActivityHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + +public class NoTitleHandler extends BaseAnnotationHandler { + + public NoTitleHandler(ProcessingEnvironment processingEnvironment) { + super(NoTitle.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.hasEActivity(element, validatedElements, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EActivityHolder holder) { + JFieldRef noTitle = holder.classes().WINDOW.staticRef("FEATURE_NO_TITLE"); + + holder.getInit().body().invoke("requestWindowFeature").arg(noTitle); + } +} From 7b5f76a488bc82f0f19b1bb7c7c23a43f3e6268d Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Tue, 4 Jun 2013 19:54:23 +0200 Subject: [PATCH 46/86] Implement CustomTitleHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/CustomTitleHandler.java | 46 +++++++++++++++++++ 2 files changed, 47 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 6b19424669..a829786604 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -64,6 +64,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new OptionsMenuItemHandler(processingEnvironment)); add(new OptionsItemHandler(processingEnvironment)); add(new NoTitleHandler(processingEnvironment)); + add(new CustomTitleHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java new file mode 100644 index 0000000000..1932ce9fa9 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java @@ -0,0 +1,46 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JFieldRef; +import org.androidannotations.annotations.CustomTitle; +import org.androidannotations.helper.AnnotationHelper; +import org.androidannotations.helper.IdValidatorHelper; +import org.androidannotations.holder.EActivityHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.rclass.IRClass; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + +public class CustomTitleHandler extends BaseAnnotationHandler { + + private final AnnotationHelper annotationHelper; + + public CustomTitleHandler(ProcessingEnvironment processingEnvironment) { + super(CustomTitle.class, processingEnvironment); + annotationHelper = new AnnotationHelper(processingEnv); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.hasEActivity(element, validatedElements, valid); + + validatorHelper.resIdsExist(element, IRClass.Res.LAYOUT, IdValidatorHelper.FallbackStrategy.NEED_RES_ID, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EActivityHolder holder) { + JBlock onViewChangedBody = holder.getOnViewChangedHolder().body(); + + JFieldRef contentViewId = annotationHelper.extractAnnotationFieldRefs(holder, element, getTarget(), rClass.get(IRClass.Res.LAYOUT), false).get(0); + + JFieldRef customTitleFeature = holder.classes().WINDOW.staticRef("FEATURE_CUSTOM_TITLE"); + holder.getInit().body().invoke("requestWindowFeature").arg(customTitleFeature); + onViewChangedBody.add(holder.getContextRef().invoke("getWindow").invoke("setFeatureInt").arg(customTitleFeature).arg(contentViewId)); + } +} From 2c0282417182e8ad99e347cad727136e321e1d9c Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Tue, 4 Jun 2013 19:57:35 +0200 Subject: [PATCH 47/86] Implement FullscreenHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/FullscreenHandler.java | 32 +++++++++++++++++++ 2 files changed, 33 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index a829786604..94dc9c9e0c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -65,6 +65,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new OptionsItemHandler(processingEnvironment)); add(new NoTitleHandler(processingEnvironment)); add(new CustomTitleHandler(processingEnvironment)); + add(new FullscreenHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java new file mode 100644 index 0000000000..33aecb4565 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java @@ -0,0 +1,32 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JFieldRef; +import org.androidannotations.annotations.Fullscreen; +import org.androidannotations.holder.EActivityHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + +public class FullscreenHandler extends BaseAnnotationHandler { + + public FullscreenHandler(ProcessingEnvironment processingEnvironment) { + super(Fullscreen.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.hasEActivity(element, validatedElements, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EActivityHolder holder) { + JFieldRef fullScreen = holder.classes().WINDOW_MANAGER_LAYOUT_PARAMS.staticRef("FLAG_FULLSCREEN"); + holder.getInit().body().invoke("getWindow").invoke("setFlags").arg(fullScreen).arg(fullScreen); + } +} From 6061fff2fbff65e9b068604a5a4eb9168ab84753 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Tue, 4 Jun 2013 19:59:26 +0200 Subject: [PATCH 48/86] Implement RestServiceHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/RestServiceHandler.java | 51 +++++++++++++++++++ 2 files changed, 52 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RestServiceHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 94dc9c9e0c..6ba6f91a8a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -66,6 +66,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new NoTitleHandler(processingEnvironment)); add(new CustomTitleHandler(processingEnvironment)); add(new FullscreenHandler(processingEnvironment)); + add(new RestServiceHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RestServiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RestServiceHandler.java new file mode 100644 index 0000000000..2593a058a4 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RestServiceHandler.java @@ -0,0 +1,51 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JFieldRef; +import org.androidannotations.annotations.rest.Rest; +import org.androidannotations.annotations.rest.RestService; +import org.androidannotations.helper.ModelConstants; +import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.type.TypeMirror; + +public class RestServiceHandler extends BaseAnnotationHandler { + + public RestServiceHandler(ProcessingEnvironment processingEnvironment) { + super(RestService.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); + + validatorHelper.isNotPrivate(element, valid); + + validatorHelper.typeHasAnnotation(Rest.class, element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EComponentHolder holder) { + String fieldName = element.getSimpleName().toString(); + + TypeMirror fieldTypeMirror = element.asType(); + String interfaceName = fieldTypeMirror.toString(); + + String generatedClassName = interfaceName + ModelConstants.GENERATION_SUFFIX; + + JBlock methodBody = holder.getInit().body(); + + JFieldRef field = JExpr.ref(fieldName); + + methodBody.assign(field, JExpr._new(holder.refClass(generatedClassName))); + } +} From 908c44b51a0fea3c3935f14b9f2c6705862b70d3 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Wed, 5 Jun 2013 10:38:22 +0200 Subject: [PATCH 49/86] Implement OrmLiteDaoHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/OrmLiteDaoHandler.java | 66 +++++++++++++++++++ .../androidannotations/helper/CaseHelper.java | 8 +++ .../holder/EComponentHolder.java | 34 ++++++++-- 4 files changed, 105 insertions(+), 4 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 6ba6f91a8a..cdd90567c6 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -67,6 +67,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new CustomTitleHandler(processingEnvironment)); add(new FullscreenHandler(processingEnvironment)); add(new RestServiceHandler(processingEnvironment)); + add(new OrmLiteDaoHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java new file mode 100644 index 0000000000..3fe52a8bb1 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java @@ -0,0 +1,66 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.OrmLiteDao; +import org.androidannotations.helper.TargetAnnotationHelper; +import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.type.TypeMirror; + +import static com.sun.codemodel.JExpr.ref; + +public class OrmLiteDaoHandler extends BaseAnnotationHandler { + + private TargetAnnotationHelper annotationHelper; + + public OrmLiteDaoHandler(ProcessingEnvironment processingEnvironment) { + super(OrmLiteDao.class, processingEnvironment); + annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.hasOrmLiteJars(element, valid); + + validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); + + validatorHelper.isNotPrivate(element, valid); + + validatorHelper.extendsOrmLiteDaoWithValidModelParameter(element, valid); + + validatorHelper.hasASqlLiteOpenHelperParameterizedType(element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EComponentHolder holder) { + String fieldName = element.getSimpleName().toString(); + + TypeMirror modelObjectTypeMirror = annotationHelper.extractAnnotationParameter(element, "model"); + JExpression modelClass = holder.refClass(modelObjectTypeMirror.toString()).dotclass(); + + TypeMirror databaseHelperTypeMirror = annotationHelper.extractAnnotationParameter(element, "helper"); + JFieldVar databaseHelperRef = holder.getDatabaseHelperRef(databaseHelperTypeMirror); + + JBlock initBody = holder.getInit().body(); + + JTryBlock tryBlock = initBody._try(); + tryBlock.body().assign(ref(fieldName), databaseHelperRef.invoke("getDao").arg(modelClass)); + + JCatchBlock catchBlock = tryBlock._catch(holder.classes().SQL_EXCEPTION); + JVar exception = catchBlock.param("e"); + + catchBlock.body() // + .staticInvoke(holder.classes().LOG, "e") // + .arg(holder.getGeneratedClass().name()) // + .arg("Could not create DAO " + fieldName) // + .arg(exception); + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/CaseHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/CaseHelper.java index 29324824d0..deb08eec6b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/CaseHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/CaseHelper.java @@ -60,4 +60,12 @@ public static String camelCaseToUpperSnakeCase(String camelCase) { return camelCaseToSnakeCase(camelCase).toUpperCase(); } + public static String lowerCaseFirst(String string) { + if (string.length() < 2) + return string.toLowerCase(); + String first = string.substring(0, 1).toLowerCase(); + String end = string.substring(1, string.length()); + return first + end; + } + } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java index 470609077c..e1ee3e4018 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java @@ -1,18 +1,23 @@ package org.androidannotations.holder; -import com.sun.codemodel.JExpression; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JVar; +import com.sun.codemodel.*; +import org.androidannotations.helper.CaseHelper; +import org.androidannotations.helper.ModelConstants; import org.androidannotations.process.ProcessHolder; import javax.lang.model.element.TypeElement; +import javax.lang.model.type.TypeMirror; +import java.util.HashMap; +import java.util.Map; -public abstract class EComponentHolder extends BaseGeneratedClassHolder { +import static com.sun.codemodel.JMod.PRIVATE; +public abstract class EComponentHolder extends BaseGeneratedClassHolder { protected JExpression contextRef; protected JMethod init; private JVar resourcesRef; + private Map databaseHelperRefs = new HashMap(); public EComponentHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); @@ -46,4 +51,25 @@ public JVar getResourcesRef() { private void setResourcesRef() { resourcesRef = getInit().body().decl(classes().RESOURCES, "resources_", getContextRef().invoke("getResources")); } + + public JFieldVar getDatabaseHelperRef(TypeMirror databaseHelperTypeMirror) { + JFieldVar databaseHelperRef = databaseHelperRefs.get(databaseHelperTypeMirror); + if (databaseHelperRef == null) { + databaseHelperRef = setDatabaseHelperRef(databaseHelperTypeMirror); + } + return databaseHelperRef; + } + + private JFieldVar setDatabaseHelperRef(TypeMirror databaseHelperTypeMirror) { + JClass databaseHelperClass = refClass(databaseHelperTypeMirror.toString()); + String fieldName = CaseHelper.lowerCaseFirst(databaseHelperClass.name()) + ModelConstants.GENERATION_SUFFIX; + JFieldVar databaseHelperRef = generatedClass.field(PRIVATE, databaseHelperClass, fieldName); + databaseHelperRefs.put(databaseHelperTypeMirror, databaseHelperRef); + + JExpression dbHelperClass = databaseHelperClass.dotclass(); + getInit().body().assign(databaseHelperRef, // + classes().OPEN_HELPER_MANAGER.staticInvoke("getHelper").arg(getContextRef()).arg(dbHelperClass)); + + return databaseHelperRef; + } } From f38accd9050f14b8b12f446f33e4b43bad4acf0f Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Wed, 5 Jun 2013 15:04:04 +0200 Subject: [PATCH 50/86] Implement RootContextHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/RootContextHanlder.java | 57 +++++++++++++++++++ 2 files changed, 58 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index cdd90567c6..5381ebc62c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -68,6 +68,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new FullscreenHandler(processingEnvironment)); add(new RestServiceHandler(processingEnvironment)); add(new OrmLiteDaoHandler(processingEnvironment)); + add(new RootContextHanlder(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java new file mode 100644 index 0000000000..19739bbb65 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java @@ -0,0 +1,57 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JExpression; +import org.androidannotations.annotations.RootContext; +import org.androidannotations.helper.CanonicalNameConstants; +import org.androidannotations.holder.EBeanHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.type.TypeMirror; + +import static com.sun.codemodel.JExpr.cast; +import static com.sun.codemodel.JExpr.ref; + +public class RootContextHanlder extends BaseAnnotationHandler { + + public RootContextHanlder(ProcessingEnvironment processingEnvironment) { + super(RootContext.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEBeanAnnotation(element, validatedElements, valid); + + validatorHelper.extendsContext(element, valid); + + validatorHelper.isNotPrivate(element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EBeanHolder holder) { + String fieldName = element.getSimpleName().toString(); + + TypeMirror elementType = element.asType(); + String typeQualifiedName = elementType.toString(); + + JBlock body = holder.getInit().body(); + JExpression contextRef = holder.getContextRef(); + + if (CanonicalNameConstants.CONTEXT.equals(typeQualifiedName)) { + body.assign(ref(fieldName), contextRef); + } else { + JClass extendingContextClass = holder.refClass(typeQualifiedName); + body._if(contextRef._instanceof(extendingContextClass)) // + ._then() // + .assign(ref(fieldName), cast(extendingContextClass, contextRef)); + } + } +} From 7dd74db624e7d71223b9df1f58a2836b7478ad98 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Wed, 5 Jun 2013 16:52:35 +0200 Subject: [PATCH 51/86] Implement NonConfigurationInstanceHandler --- .../handler/AnnotationHandlers.java | 1 + .../NonConfigurationInstanceHandler.java | 81 ++++++++++++++ .../holder/EActivityHolder.java | 103 ++++++++++++++++++ .../holder/NonConfigurationHolder.java | 38 +++++++ 4 files changed, 223 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NonConfigurationInstanceHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/NonConfigurationHolder.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 5381ebc62c..e5584ff741 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -69,6 +69,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new RestServiceHandler(processingEnvironment)); add(new OrmLiteDaoHandler(processingEnvironment)); add(new RootContextHanlder(processingEnvironment)); + add(new NonConfigurationInstanceHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NonConfigurationInstanceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NonConfigurationInstanceHandler.java new file mode 100644 index 0000000000..0354c0fa26 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NonConfigurationInstanceHandler.java @@ -0,0 +1,81 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.Bean; +import org.androidannotations.annotations.NonConfigurationInstance; +import org.androidannotations.helper.APTCodeModelHelper; +import org.androidannotations.helper.AnnotationHelper; +import org.androidannotations.holder.EActivityHolder; +import org.androidannotations.holder.NonConfigurationHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.type.TypeMirror; + +import static com.sun.codemodel.JExpr.*; +import static org.androidannotations.helper.ModelConstants.GENERATION_SUFFIX; + +public class NonConfigurationInstanceHandler extends BaseAnnotationHandler { + + private final APTCodeModelHelper codeModelHelper; + private final AnnotationHelper annotationHelper; + + public NonConfigurationInstanceHandler(ProcessingEnvironment processingEnvironment) { + super(NonConfigurationInstance.class, processingEnvironment); + annotationHelper = new AnnotationHelper(processingEnv); + codeModelHelper = new APTCodeModelHelper(); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEActivity(element, validatedElements, valid); + + validatorHelper.isNotPrivate(element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EActivityHolder holder) throws JClassAlreadyExistsException { + String fieldName = element.getSimpleName().toString(); + JClass fieldType = codeModelHelper.typeMirrorToJClass(element.asType(), holder); + + NonConfigurationHolder ncHolder = holder.getNonConfigurationHolder(); + JFieldVar ncHolderField = ncHolder.createField(fieldName, fieldType); + + injectInInit(element, holder, fieldName, ncHolderField); + retainInOnRetain(holder, fieldName, ncHolderField); + } + + private void injectInInit(Element element, EActivityHolder holder, String fieldName, JFieldVar ncHolderField) throws JClassAlreadyExistsException { + JBlock initIfNonConfigurationNotNullBlock = holder.getInitIfNonConfigurationNotNullBlock(); + JVar initNonConfigurationInstance = holder.getInitNonConfigurationInstance(); + initIfNonConfigurationNotNullBlock.assign(ref(fieldName), initNonConfigurationInstance.ref(ncHolderField)); + rebindContextIfBean(element, holder, initIfNonConfigurationNotNullBlock, ncHolderField); + } + + private void retainInOnRetain(EActivityHolder holder, String fieldName, JFieldVar ncHolderField) throws JClassAlreadyExistsException { + JBlock onRetainNonConfigurationInstanceBindBlock = holder.getOnRetainNonConfigurationInstanceBindBlock(); + JVar onRetainNonConfigurationInstance = holder.getOnRetainNonConfigurationInstance(); + onRetainNonConfigurationInstanceBindBlock.assign(onRetainNonConfigurationInstance.ref(ncHolderField), ref(fieldName)); + } + + private void rebindContextIfBean(Element element, EActivityHolder holder, JBlock initIfNonConfigurationNotNullBlock, JFieldVar field) { + boolean hasBeanAnnotation = element.getAnnotation(Bean.class) != null; + if (hasBeanAnnotation) { + + TypeMirror elementType = annotationHelper.extractAnnotationClassParameter(element, Bean.class.getName()); + if (elementType == null) { + elementType = element.asType(); + } + String typeQualifiedName = elementType.toString(); + JClass fieldGeneratedBeanClass = holder.refClass(typeQualifiedName + GENERATION_SUFFIX); + + initIfNonConfigurationNotNullBlock.invoke(cast(fieldGeneratedBeanClass, field), "rebind").arg(_this()); + } + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java index b086bd07ca..b7fb4ce96f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java @@ -44,6 +44,12 @@ public class EActivityHolder extends EComponentHolder implements HasIntentBuilde private JVar onOptionsItemSelectedItem; private JVar onOptionsItemSelectedItemId; private JBlock onOptionsItemSelectedIfElseBlock; + private NonConfigurationHolder nonConfigurationHolder; + private JBlock initIfNonConfigurationNotNullBlock; + private JVar initNonConfigurationInstance; + private JMethod getLastNonConfigurationInstance; + private JBlock onRetainNonConfigurationInstanceBindBlock; + private JVar onRetainNonConfigurationInstance; public EActivityHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); @@ -570,4 +576,101 @@ public JBlock getOnOptionsItemSelectedIfElseBlock() { } return onOptionsItemSelectedIfElseBlock; } + + public NonConfigurationHolder getNonConfigurationHolder() throws JClassAlreadyExistsException { + if (nonConfigurationHolder == null) { + setNonConfigurationHolder(); + } + return nonConfigurationHolder; + } + + private void setNonConfigurationHolder() throws JClassAlreadyExistsException { + nonConfigurationHolder = new NonConfigurationHolder(this); + } + + public JBlock getInitIfNonConfigurationNotNullBlock() throws JClassAlreadyExistsException { + if (initIfNonConfigurationNotNullBlock == null) { + setInitNonConfigurationInstance(); + } + return initIfNonConfigurationNotNullBlock; + } + + public JVar getInitNonConfigurationInstance() throws JClassAlreadyExistsException { + if (initNonConfigurationInstance == null) { + setInitNonConfigurationInstance(); + } + return initNonConfigurationInstance; + } + + private void setInitNonConfigurationInstance() throws JClassAlreadyExistsException { + JBlock initBody = getInit().body(); + JDefinedClass ncHolderClass = getNonConfigurationHolder().getGeneratedClass(); + initNonConfigurationInstance = initBody.decl(ncHolderClass, "nonConfigurationInstance", cast(ncHolderClass, _super().invoke(getGetLastNonConfigurationInstance()))); + initIfNonConfigurationNotNullBlock = initBody._if(initNonConfigurationInstance.ne(_null()))._then(); + } + + public JMethod getGetLastNonConfigurationInstance() throws JClassAlreadyExistsException { + if (getLastNonConfigurationInstance == null) { + setGetLastNonConfigurationInstance(); + } + return getLastNonConfigurationInstance; + } + + private void setGetLastNonConfigurationInstance() throws JClassAlreadyExistsException { + AnnotationHelper annotationHelper = new AnnotationHelper(processingEnvironment()); + TypeElement fragmentActivityTypeElement = annotationHelper.typeElementFromQualifiedName(CanonicalNameConstants.FRAGMENT_ACTIVITY); + TypeElement typeElement = annotationHelper.typeElementFromQualifiedName(generatedClass._extends().fullName()); + String getLastNonConfigurationInstanceName = "getLastNonConfigurationInstance"; + if (fragmentActivityTypeElement != null && annotationHelper.isSubtype(typeElement.asType(), fragmentActivityTypeElement.asType())) { + getLastNonConfigurationInstanceName = "getLastCustomNonConfigurationInstance"; + } + + NonConfigurationHolder ncHolder = getNonConfigurationHolder(); + JDefinedClass ncHolderClass = ncHolder.getGeneratedClass(); + JFieldVar superNonConfigurationInstanceField = ncHolder.getSuperNonConfigurationInstanceField(); + + getLastNonConfigurationInstance = generatedClass.method(PUBLIC, Object.class, getLastNonConfigurationInstanceName); + getLastNonConfigurationInstance.annotate(Override.class); + JBlock body = getLastNonConfigurationInstance.body(); + JVar nonConfigurationInstance = body.decl(ncHolderClass, "nonConfigurationInstance", cast(ncHolderClass, _super().invoke(getLastNonConfigurationInstance))); + body._if(nonConfigurationInstance.eq(_null()))._then()._return(_null()); + body._return(nonConfigurationInstance.ref(superNonConfigurationInstanceField)); + } + + public JBlock getOnRetainNonConfigurationInstanceBindBlock() throws JClassAlreadyExistsException { + if (onRetainNonConfigurationInstanceBindBlock == null) { + setOnRetainNonConfigurationInstance(); + } + return onRetainNonConfigurationInstanceBindBlock; + } + + public JVar getOnRetainNonConfigurationInstance() throws JClassAlreadyExistsException { + if (onRetainNonConfigurationInstance == null) { + setOnRetainNonConfigurationInstance(); + } + return onRetainNonConfigurationInstance; + } + + private void setOnRetainNonConfigurationInstance() throws JClassAlreadyExistsException { + AnnotationHelper annotationHelper = new AnnotationHelper(processingEnvironment()); + TypeElement fragmentActivityTypeElement = annotationHelper.typeElementFromQualifiedName(CanonicalNameConstants.FRAGMENT_ACTIVITY); + TypeElement typeElement = annotationHelper.typeElementFromQualifiedName(generatedClass._extends().fullName()); + + String onRetainNonConfigurationInstanceName = "onRetainNonConfigurationInstance"; + if (fragmentActivityTypeElement != null && annotationHelper.isSubtype(typeElement.asType(), fragmentActivityTypeElement.asType())) { + onRetainNonConfigurationInstanceName = "onRetainCustomNonConfigurationInstance"; + } + + NonConfigurationHolder ncHolder = getNonConfigurationHolder(); + JDefinedClass ncHolderClass = ncHolder.getGeneratedClass(); + + JMethod onRetainNonConfigurationInstanceMethod = generatedClass.method(PUBLIC, ncHolderClass, onRetainNonConfigurationInstanceName); + onRetainNonConfigurationInstanceMethod.annotate(Override.class); + JBlock methodBody = onRetainNonConfigurationInstanceMethod.body(); + onRetainNonConfigurationInstance = methodBody.decl(ncHolderClass, "nonConfigurationInstanceState_", _new(ncHolderClass)); + JExpression superCall = _super().invoke(onRetainNonConfigurationInstanceMethod); + methodBody.assign(onRetainNonConfigurationInstance.ref(ncHolder.getSuperNonConfigurationInstanceField()), superCall); + onRetainNonConfigurationInstanceBindBlock = methodBody.block(); + methodBody._return(onRetainNonConfigurationInstance); + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/NonConfigurationHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/NonConfigurationHolder.java new file mode 100644 index 0000000000..b5005ae37f --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/NonConfigurationHolder.java @@ -0,0 +1,38 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.*; + +import static com.sun.codemodel.JMod.PUBLIC; + +public class NonConfigurationHolder { + + private JDefinedClass generatedClass; + private JFieldVar superNonConfigurationInstanceField; + + public NonConfigurationHolder(EActivityHolder eActivityHolder) throws JClassAlreadyExistsException { + setGeneratedClass(eActivityHolder); + } + + private void setGeneratedClass(EActivityHolder eActivityHolder) throws JClassAlreadyExistsException { + generatedClass = eActivityHolder.generatedClass._class(JMod.PRIVATE | JMod.STATIC, "NonConfigurationInstancesHolder"); + } + + public JDefinedClass getGeneratedClass() { + return generatedClass; + } + + public JFieldVar getSuperNonConfigurationInstanceField() { + if (superNonConfigurationInstanceField == null) { + setSuperNonConfigurationInstanceField(); + } + return superNonConfigurationInstanceField; + } + + private void setSuperNonConfigurationInstanceField() { + superNonConfigurationInstanceField = generatedClass.field(PUBLIC, Object.class, "superNonConfigurationInstance"); + } + + public JFieldVar createField(String fieldName, JClass fieldType) { + return generatedClass.field(PUBLIC, fieldType, fieldName); + } +} From 4ec69c90f1b3e6013665b7a6b5f9b8a6ad6b8e35 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Wed, 5 Jun 2013 17:13:12 +0200 Subject: [PATCH 52/86] Implement BeanHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/BeanHandler.java | 68 +++++++++++++++++++ 2 files changed, 69 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index e5584ff741..8f118d921f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -70,6 +70,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new OrmLiteDaoHandler(processingEnvironment)); add(new RootContextHanlder(processingEnvironment)); add(new NonConfigurationInstanceHandler(processingEnvironment)); + add(new BeanHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java new file mode 100644 index 0000000000..ce5d9cc0e4 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java @@ -0,0 +1,68 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JFieldRef; +import com.sun.codemodel.JInvocation; +import org.androidannotations.annotations.Bean; +import org.androidannotations.annotations.EBean; +import org.androidannotations.annotations.NonConfigurationInstance; +import org.androidannotations.helper.TargetAnnotationHelper; +import org.androidannotations.holder.EBeanHolder; +import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.type.TypeMirror; + +import static com.sun.codemodel.JExpr._null; +import static com.sun.codemodel.JExpr.ref; +import static org.androidannotations.helper.ModelConstants.GENERATION_SUFFIX; + +public class BeanHandler extends BaseAnnotationHandler { + + private final TargetAnnotationHelper annotationHelper; + + public BeanHandler(ProcessingEnvironment processingEnvironment) { + super(Bean.class, processingEnvironment); + annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); + + validatorHelper.isNotPrivate(element, valid); + + validatorHelper.typeOrTargetValueHasAnnotation(EBean.class, element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EComponentHolder holder) throws Exception { + TypeMirror elementType = annotationHelper.extractAnnotationClassParameter(element); + if (elementType == null) { + elementType = element.asType(); + } + + String fieldName = element.getSimpleName().toString(); + String typeQualifiedName = elementType.toString(); + JClass injectedClass = holder.refClass(typeQualifiedName + GENERATION_SUFFIX); + + JFieldRef beanField = ref(fieldName); + JBlock block = holder.getInit().body(); + + boolean hasNonConfigurationInstanceAnnotation = element.getAnnotation(NonConfigurationInstance.class) != null; + if (hasNonConfigurationInstanceAnnotation) { + block = block._if(beanField.eq(_null()))._then(); + } + + JInvocation getInstance = injectedClass.staticInvoke(EBeanHolder.GET_INSTANCE_METHOD_NAME).arg(holder.getContextRef()); + block.assign(beanField, getInstance); + } +} From d208897fb7236e92c8b52de652c989b969d7e463 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 6 Jun 2013 00:07:46 +0200 Subject: [PATCH 53/86] Refactor EComponentHolder with View support --- .../handler/AbstractListenerHandler.java | 14 +- .../handler/CustomTitleHandler.java | 2 +- .../handler/FragmentByIdHandler.java | 8 +- .../handler/FragmentByTagHandler.java | 8 +- .../handler/FromHtmlHandler.java | 8 +- .../handler/RoboGuiceHandler.java | 2 +- .../handler/ViewByIdHandler.java | 12 +- .../helper/FindFragmentHelper.java | 73 --------- .../holder/EActivityHolder.java | 57 +------ .../holder/EBeanHolder.java | 71 +-------- .../EComponentWithViewSupportHolder.java | 140 ++++++++++++++++++ .../holder/EFragmentHolder.java | 74 +-------- .../holder/EViewHolder.java | 71 +-------- .../holder/HasViewChanged.java | 13 -- .../holder/ViewChangedHolder.java | 58 -------- 15 files changed, 175 insertions(+), 436 deletions(-) delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/FindFragmentHelper.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentWithViewSupportHolder.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasViewChanged.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/ViewChangedHolder.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java index 60488de75a..60ca309443 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java @@ -4,8 +4,7 @@ import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.IdAnnotationHelper; import org.androidannotations.helper.IdValidatorHelper; -import org.androidannotations.holder.HasViewChanged; -import org.androidannotations.holder.ViewChangedHolder; +import org.androidannotations.holder.EComponentWithViewSupportHolder; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.ProcessHolder; @@ -21,10 +20,10 @@ import static com.sun.codemodel.JExpr.*; -public abstract class AbstractListenerHandler extends BaseAnnotationHandler { +public abstract class AbstractListenerHandler extends BaseAnnotationHandler { private IdAnnotationHelper helper; - private HasViewChanged holder; + private EComponentWithViewSupportHolder holder; private String methodName; public AbstractListenerHandler(Class targetClass, ProcessingEnvironment processingEnvironment) { @@ -59,7 +58,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { } @Override - public void process(Element element, HasViewChanged holder) { + public void process(Element element, EComponentWithViewSupportHolder holder) { this.holder = holder; this.methodName = element.getSimpleName().toString(); @@ -84,10 +83,9 @@ public void process(Element element, HasViewChanged holder) { processParameters(listenerMethod, call, parameters); for (JFieldRef idRef : idsRefs) { - ViewChangedHolder onViewChanged = holder.getOnViewChangedHolder(); - JBlock block = onViewChanged.body().block(); + JBlock block = holder.getOnViewChangedBody().block(); - JExpression findViewExpression = onViewChanged.findViewById(idRef); + JExpression findViewExpression = holder.findViewById(idRef); if (!getViewClass().equals(classes().VIEW)) { findViewExpression = cast(getViewClass(), findViewExpression); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java index 1932ce9fa9..82197b92d2 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java @@ -35,7 +35,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { @Override public void process(Element element, EActivityHolder holder) { - JBlock onViewChangedBody = holder.getOnViewChangedHolder().body(); + JBlock onViewChangedBody = holder.getOnViewChangedBody(); JFieldRef contentViewId = annotationHelper.extractAnnotationFieldRefs(holder, element, getTarget(), rClass.get(IRClass.Res.LAYOUT), false).get(0); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java index c11b69049d..a4311bc200 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java @@ -8,7 +8,7 @@ import org.androidannotations.helper.CanonicalNameConstants; import org.androidannotations.helper.IdAnnotationHelper; import org.androidannotations.helper.IdValidatorHelper; -import org.androidannotations.holder.HasViewChanged; +import org.androidannotations.holder.EComponentWithViewSupportHolder; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; import org.androidannotations.rclass.IRClass; @@ -21,7 +21,7 @@ import static com.sun.codemodel.JExpr.*; -public class FragmentByIdHandler extends BaseAnnotationHandler { +public class FragmentByIdHandler extends BaseAnnotationHandler { private IdAnnotationHelper annotationHelper; @@ -51,7 +51,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { } @Override - public void process(Element element, HasViewChanged holder) { + public void process(Element element, EComponentWithViewSupportHolder holder) { TypeMirror elementType = element.asType(); String typeQualifiedName = elementType.toString(); @@ -69,7 +69,7 @@ public void process(Element element, HasViewChanged holder) { JFieldRef idRef = annotationHelper.extractOneAnnotationFieldRef(holder, element, IRClass.Res.ID, true); - JBlock methodBody = holder.getOnViewChangedHolder().body(); + JBlock methodBody = holder.getOnViewChangedBody(); methodBody.assign(ref(fieldName), cast(holder.refClass(typeQualifiedName), invoke(findFragmentById).arg(idRef))); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java index fd9e6fdc7d..b112594ce3 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java @@ -6,7 +6,7 @@ import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.CanonicalNameConstants; import org.androidannotations.helper.IdAnnotationHelper; -import org.androidannotations.holder.HasViewChanged; +import org.androidannotations.holder.EComponentWithViewSupportHolder; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; import org.androidannotations.rclass.IRClass; @@ -18,7 +18,7 @@ import static com.sun.codemodel.JExpr.*; -public class FragmentByTagHandler extends BaseAnnotationHandler { +public class FragmentByTagHandler extends BaseAnnotationHandler { private IdAnnotationHelper annotationHelper; @@ -46,7 +46,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { } @Override - public void process(Element element, HasViewChanged holder) { + public void process(Element element, EComponentWithViewSupportHolder holder) { TypeMirror elementType = element.asType(); String typeQualifiedName = elementType.toString(); @@ -67,7 +67,7 @@ public void process(Element element, HasViewChanged holder) { tagValue = fieldName; } - JBlock methodBody = holder.getOnViewChangedHolder().body(); + JBlock methodBody = holder.getOnViewChangedBody(); methodBody.assign(ref(fieldName), cast(holder.refClass(typeQualifiedName), invoke(findFragmentByTag).arg(lit(tagValue)))); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java index 53ff18b706..fe70f38232 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java @@ -6,7 +6,7 @@ import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.IdAnnotationHelper; import org.androidannotations.helper.IdValidatorHelper; -import org.androidannotations.holder.HasViewChanged; +import org.androidannotations.holder.EComponentWithViewSupportHolder; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.ProcessHolder; @@ -19,7 +19,7 @@ import static com.sun.codemodel.JExpr._null; import static com.sun.codemodel.JExpr.ref; -public class FromHtmlHandler extends BaseAnnotationHandler { +public class FromHtmlHandler extends BaseAnnotationHandler { private IdAnnotationHelper annotationHelper; @@ -49,14 +49,14 @@ public boolean validate(Element element, AnnotationElements validatedElements) { } @Override - public void process(Element element, HasViewChanged holder) { + public void process(Element element, EComponentWithViewSupportHolder holder) { ProcessHolder.Classes classes = holder.classes(); String fieldName = element.getSimpleName().toString(); JFieldRef idRef = annotationHelper.extractOneAnnotationFieldRef(holder, element, IRClass.Res.STRING, true); - JBlock methodBody = holder.getOnViewChangedHolder().body(); + JBlock methodBody = holder.getOnViewChangedBody(); methodBody // ._if(ref(fieldName).ne(_null())) // ._then() // diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java index 2ad286c751..c675e894c9 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java @@ -118,7 +118,7 @@ private void beforeCreateMethod(EActivityHolder holder, JFieldVar scope, JFieldV } private void afterSetContentView(EActivityHolder holder, JFieldVar scope, JFieldVar eventManager) { - JBlock onViewChanged = holder.getOnViewChangedHolder().body(); + JBlock onViewChanged = holder.getOnViewChangedBody(); onViewChanged.invoke(scope, "injectViews"); fireEvent(eventManager, onViewChanged, holder.classes().ON_CONTENT_VIEW_AVAILABLE_EVENT); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java index fa84008ade..f6287daaf6 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java @@ -6,8 +6,7 @@ import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.IdAnnotationHelper; import org.androidannotations.helper.IdValidatorHelper; -import org.androidannotations.holder.HasViewChanged; -import org.androidannotations.holder.ViewChangedHolder; +import org.androidannotations.holder.EComponentWithViewSupportHolder; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; import org.androidannotations.rclass.IRClass; @@ -20,7 +19,7 @@ import static com.sun.codemodel.JExpr.cast; import static com.sun.codemodel.JExpr.ref; -public class ViewByIdHandler extends BaseAnnotationHandler { +public class ViewByIdHandler extends BaseAnnotationHandler { private IdAnnotationHelper annotationHelper; @@ -52,7 +51,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { } @Override - public void process(Element element, HasViewChanged holder) { + public void process(Element element, EComponentWithViewSupportHolder holder) { String fieldName = element.getSimpleName().toString(); TypeMirror uiFieldTypeMirror = element.asType(); @@ -60,8 +59,7 @@ public void process(Element element, HasViewChanged holder) { JFieldRef idRef = annotationHelper.extractOneAnnotationFieldRef(holder, element, IRClass.Res.ID, true); - ViewChangedHolder onViewChanged = holder.getOnViewChangedHolder(); - JBlock methodBody = onViewChanged.body(); - methodBody.assign(ref(fieldName), cast(holder.refClass(typeQualifiedName), onViewChanged.findViewById(idRef))); + JBlock methodBody = holder.getOnViewChangedBody(); + methodBody.assign(ref(fieldName), cast(holder.refClass(typeQualifiedName), holder.findViewById(idRef))); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/FindFragmentHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/FindFragmentHelper.java deleted file mode 100644 index 9c31e4b806..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/FindFragmentHelper.java +++ /dev/null @@ -1,73 +0,0 @@ -package org.androidannotations.helper; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JVar; -import org.androidannotations.holder.EComponentHolder; - -import static com.sun.codemodel.JExpr._null; -import static com.sun.codemodel.JExpr.cast; -import static com.sun.codemodel.JMod.PRIVATE; - -public class FindFragmentHelper { - - public static JMethod createFindNativeFragmentById(EComponentHolder holder) { - JMethod method = holder.getGeneratedClass().method(PRIVATE, holder.classes().FRAGMENT, "findNativeFragmentById"); - JVar idParam = method.param(holder.codeModel().INT, "id"); - - JBlock body = method.body(); - - body._if(holder.getContextRef()._instanceof(holder.classes().ACTIVITY).not())._then()._return(_null()); - - JVar activityVar = body.decl(holder.classes().ACTIVITY, "activity_", cast(holder.classes().ACTIVITY, holder.getContextRef())); - - body._return(activityVar.invoke("getFragmentManager").invoke("findFragmentById").arg(idParam)); - - return method; - } - - public static JMethod createFindSupportFragmentById(EComponentHolder holder) { - JMethod method = holder.getGeneratedClass().method(PRIVATE, holder.classes().SUPPORT_V4_FRAGMENT, "findSupportFragmentById"); - JVar idParam = method.param(holder.codeModel().INT, "id"); - - JBlock body = method.body(); - - body._if(holder.getContextRef()._instanceof(holder.classes().FRAGMENT_ACTIVITY).not())._then()._return(_null()); - - JVar activityVar = body.decl(holder.classes().FRAGMENT_ACTIVITY, "activity_", cast(holder.classes().FRAGMENT_ACTIVITY, holder.getContextRef())); - - body._return(activityVar.invoke("getSupportFragmentManager").invoke("findFragmentById").arg(idParam)); - - return method; - } - - public static JMethod createFindNativeFragmentByTag(EComponentHolder holder) { - JMethod method = holder.getGeneratedClass().method(PRIVATE, holder.classes().FRAGMENT, "findNativeFragmentByTag"); - JVar tagParam = method.param(holder.classes().STRING, "tag"); - - JBlock body = method.body(); - - body._if(holder.getContextRef()._instanceof(holder.classes().ACTIVITY).not())._then()._return(_null()); - - JVar activityVar = body.decl(holder.classes().ACTIVITY, "activity_", cast(holder.classes().ACTIVITY, holder.getContextRef())); - - body._return(activityVar.invoke("getFragmentManager").invoke("findFragmentByTag").arg(tagParam)); - - return method; - } - - public static JMethod createFindSupportFragmentByTag(EComponentHolder holder) { - JMethod method = holder.getGeneratedClass().method(PRIVATE, holder.classes().SUPPORT_V4_FRAGMENT, "findSupportFragmentByTag"); - JVar tagParam = method.param(holder.classes().STRING, "tag"); - - JBlock body = method.body(); - - body._if(holder.getContextRef()._instanceof(holder.classes().FRAGMENT_ACTIVITY).not())._then()._return(_null()); - - JVar activityVar = body.decl(holder.classes().FRAGMENT_ACTIVITY, "activity_", cast(holder.classes().FRAGMENT_ACTIVITY, holder.getContextRef())); - - body._return(activityVar.invoke("getSupportFragmentManager").invoke("findFragmentByTag").arg(tagParam)); - - return method; - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java index b7fb4ce96f..8a2c3164b6 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java @@ -18,9 +18,8 @@ import static com.sun.codemodel.JMod.PRIVATE; import static com.sun.codemodel.JMod.PUBLIC; -public class EActivityHolder extends EComponentHolder implements HasIntentBuilder, HasViewChanged, HasExtras, HasInstanceState, HasOptionsMenu { +public class EActivityHolder extends EComponentWithViewSupportHolder implements HasIntentBuilder, HasExtras, HasInstanceState, HasOptionsMenu { - private ViewNotifierHelper viewNotifierHelper; private GreenDroidHelper greenDroidHelper; private JMethod onCreate; private JMethod setIntent; @@ -28,11 +27,6 @@ public class EActivityHolder extends EComponentHolder implements HasIntentBuilde private JVar initSavedInstanceParam; private JDefinedClass intentBuilderClass; private JFieldVar intentField; - private ViewChangedHolder viewChangedHolder; - private JMethod findNativeFragmentById; - private JMethod findSupportFragmentById; - private JMethod findNativeFragmentByTag; - private JMethod findSupportFragmentByTag; private InstanceStateHolder instanceStateHolder; private RoboGuiceHolder roboGuiceHolder; private JMethod injectExtrasMethod; @@ -53,7 +47,6 @@ public class EActivityHolder extends EComponentHolder implements HasIntentBuilde public EActivityHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); - viewNotifierHelper = new ViewNotifierHelper(this); instanceStateHolder = new InstanceStateHolder(this); createIntentBuilder(); handleBackPressed(); @@ -242,26 +235,7 @@ private boolean usesActionBarSherlock() { } @Override - public ViewChangedHolder getOnViewChangedHolder() { - if (viewChangedHolder == null) { - setViewChangedHolder(); - } - return viewChangedHolder; - } - - private void setViewChangedHolder() { - viewChangedHolder = ViewChangedHolder.createViewChangedHolder(this); - } - - @Override - public JMethod getFindNativeFragmentById() { - if (findNativeFragmentById == null) { - setFindNativeFragmentById(); - } - return findNativeFragmentById; - } - - private void setFindNativeFragmentById() { + protected void setFindNativeFragmentById() { JMethod method = generatedClass.method(PRIVATE, classes().FRAGMENT, "findNativeFragmentById"); JVar idParam = method.param(codeModel().INT, "id"); JBlock body = method.body(); @@ -270,14 +244,7 @@ private void setFindNativeFragmentById() { } @Override - public JMethod getFindSupportFragmentById() { - if (findSupportFragmentById == null) { - setFindSupportFragmentById(); - } - return findSupportFragmentById; - } - - private void setFindSupportFragmentById() { + protected void setFindSupportFragmentById() { JMethod method = generatedClass.method(PRIVATE, classes().SUPPORT_V4_FRAGMENT, "findSupportFragmentById"); JVar idParam = method.param(codeModel().INT, "id"); JBlock body = method.body(); @@ -286,14 +253,7 @@ private void setFindSupportFragmentById() { } @Override - public JMethod getFindNativeFragmentByTag() { - if (findNativeFragmentByTag == null) { - setFindNativeFragmentByTag(); - } - return findNativeFragmentByTag; - } - - private void setFindNativeFragmentByTag() { + protected void setFindNativeFragmentByTag() { JMethod method = generatedClass.method(PRIVATE, classes().FRAGMENT, "findNativeFragmentByTag"); JVar tagParam = method.param(classes().STRING, "tag"); JBlock body = method.body(); @@ -302,14 +262,7 @@ private void setFindNativeFragmentByTag() { } @Override - public JMethod getFindSupportFragmentByTag() { - if (findSupportFragmentByTag == null) { - setFindSupportFragmentByTag(); - } - return findSupportFragmentByTag; - } - - private void setFindSupportFragmentByTag() { + protected void setFindSupportFragmentByTag() { JMethod method = generatedClass.method(PRIVATE, classes().SUPPORT_V4_FRAGMENT, "findSupportFragmentByTag"); JVar tagParam = method.param(classes().STRING, "tag"); JBlock body = method.body(); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java index df8f4ac854..2cf523d8e5 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java @@ -4,8 +4,6 @@ import com.sun.codemodel.JFieldVar; import com.sun.codemodel.JMethod; import com.sun.codemodel.JVar; -import org.androidannotations.helper.FindFragmentHelper; -import org.androidannotations.helper.ViewNotifierHelper; import org.androidannotations.process.ProcessHolder; import javax.lang.model.element.ExecutableElement; @@ -18,22 +16,15 @@ import static com.sun.codemodel.JMod.*; import static org.androidannotations.helper.ModelConstants.GENERATION_SUFFIX; -public class EBeanHolder extends EComponentHolder implements HasViewChanged { +public class EBeanHolder extends EComponentWithViewSupportHolder { public static final String GET_INSTANCE_METHOD_NAME = "getInstance" + GENERATION_SUFFIX; - private ViewNotifierHelper viewNotifierHelper; - private ViewChangedHolder viewChangedHolder; private JFieldVar contextField; private JMethod constructor; - private JMethod findNativeFragmentById; - private JMethod findSupportFragmentById; - private JMethod findNativeFragmentByTag; - private JMethod findSupportFragmentByTag; public EBeanHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); - viewNotifierHelper = new ViewNotifierHelper(this); setConstructor(); } @@ -101,64 +92,4 @@ public void createRebindMethod() { body.assign(getContextField(), contextParam); body.invoke(getInit()); } - - @Override - public ViewChangedHolder getOnViewChangedHolder() { - if (viewChangedHolder == null) { - setViewChangedHolder(); - } - return viewChangedHolder; - } - - private void setViewChangedHolder() { - viewChangedHolder = ViewChangedHolder.createViewChangedHolder(this); - } - - @Override - public JMethod getFindNativeFragmentById() { - if (findNativeFragmentById == null) { - setFindNativeFragmentById(); - } - return findNativeFragmentById; - } - - private void setFindNativeFragmentById() { - findNativeFragmentById = FindFragmentHelper.createFindNativeFragmentById(this); - } - - @Override - public JMethod getFindSupportFragmentById() { - if (findSupportFragmentById == null) { - setFindSupportFragmentById(); - } - return findSupportFragmentById; - } - - private void setFindSupportFragmentById() { - findSupportFragmentById = FindFragmentHelper.createFindSupportFragmentById(this); - } - - @Override - public JMethod getFindNativeFragmentByTag() { - if (findNativeFragmentByTag == null) { - setFindNativeFragmentByTag(); - } - return findNativeFragmentByTag; - } - - private void setFindNativeFragmentByTag() { - findNativeFragmentByTag = FindFragmentHelper.createFindNativeFragmentByTag(this); - } - - @Override - public JMethod getFindSupportFragmentByTag() { - if (findSupportFragmentByTag == null) { - setFindSupportFragmentByTag(); - } - return findSupportFragmentByTag; - } - - private void setFindSupportFragmentByTag() { - findSupportFragmentByTag = FindFragmentHelper.createFindSupportFragmentByTag(this); - } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentWithViewSupportHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentWithViewSupportHolder.java new file mode 100644 index 0000000000..f19ec1d026 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentWithViewSupportHolder.java @@ -0,0 +1,140 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.*; +import org.androidannotations.api.view.HasViews; +import org.androidannotations.api.view.OnViewChangedListener; +import org.androidannotations.api.view.OnViewChangedNotifier; +import org.androidannotations.helper.ViewNotifierHelper; +import org.androidannotations.process.ProcessHolder; + +import javax.lang.model.element.TypeElement; + +import static com.sun.codemodel.JExpr.*; +import static com.sun.codemodel.JMod.PRIVATE; +import static com.sun.codemodel.JMod.PUBLIC; + +public abstract class EComponentWithViewSupportHolder extends EComponentHolder { + + protected ViewNotifierHelper viewNotifierHelper; + private JBlock onViewChangedBody; + private JVar onViewChangedHasViewsParam; + protected JMethod findNativeFragmentById; + protected JMethod findSupportFragmentById; + protected JMethod findNativeFragmentByTag; + protected JMethod findSupportFragmentByTag; + + public EComponentWithViewSupportHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + super(processHolder, annotatedElement); + viewNotifierHelper = new ViewNotifierHelper(this); + } + + public JBlock getOnViewChangedBody() { + if (onViewChangedBody == null) { + setOnViewChanged(); + } + return onViewChangedBody; + } + + public JVar getOnViewChangedHasViewsParam() { + if (onViewChangedHasViewsParam == null) { + setOnViewChanged(); + } + return onViewChangedHasViewsParam; + } + + protected void setOnViewChanged() { + getGeneratedClass()._implements(OnViewChangedListener.class); + JMethod onViewChanged = getGeneratedClass().method(PUBLIC, codeModel().VOID, "onViewChanged"); + onViewChanged.annotate(Override.class); + onViewChangedBody = onViewChanged.body(); + onViewChangedHasViewsParam = onViewChanged.param(HasViews.class, "hasViews"); + JClass notifierClass = refClass(OnViewChangedNotifier.class); + getInit().body().staticInvoke(notifierClass, "registerOnViewChangedListener").arg(_this()); + } + + public JInvocation findViewById(JFieldRef idRef) { + JInvocation findViewById = invoke(getOnViewChangedHasViewsParam(), "findViewById"); + findViewById.arg(idRef); + return findViewById; + } + + public JMethod getFindNativeFragmentById() { + if (findNativeFragmentById == null) { + setFindNativeFragmentById(); + } + return findNativeFragmentById; + } + + protected void setFindNativeFragmentById() { + findNativeFragmentById = getGeneratedClass().method(PRIVATE, classes().FRAGMENT, "findNativeFragmentById"); + JVar idParam = findNativeFragmentById.param(codeModel().INT, "id"); + + JBlock body = findNativeFragmentById.body(); + + body._if(getContextRef()._instanceof(classes().ACTIVITY).not())._then()._return(_null()); + + JVar activityVar = body.decl(classes().ACTIVITY, "activity_", cast(classes().ACTIVITY, getContextRef())); + + body._return(activityVar.invoke("getFragmentManager").invoke("findFragmentById").arg(idParam)); + } + + public JMethod getFindSupportFragmentById() { + if (findSupportFragmentById == null) { + setFindSupportFragmentById(); + } + return findSupportFragmentById; + } + + protected void setFindSupportFragmentById() { + findSupportFragmentById = getGeneratedClass().method(PRIVATE, classes().SUPPORT_V4_FRAGMENT, "findSupportFragmentById"); + JVar idParam = findSupportFragmentById.param(codeModel().INT, "id"); + + JBlock body = findSupportFragmentById.body(); + + body._if(getContextRef()._instanceof(classes().FRAGMENT_ACTIVITY).not())._then()._return(_null()); + + JVar activityVar = body.decl(classes().FRAGMENT_ACTIVITY, "activity_", cast(classes().FRAGMENT_ACTIVITY, getContextRef())); + + body._return(activityVar.invoke("getSupportFragmentManager").invoke("findFragmentById").arg(idParam)); + } + + public JMethod getFindNativeFragmentByTag() { + if (findNativeFragmentByTag == null) { + setFindNativeFragmentByTag(); + } + return findNativeFragmentByTag; + } + + protected void setFindNativeFragmentByTag() { + findNativeFragmentByTag = getGeneratedClass().method(PRIVATE, classes().FRAGMENT, "findNativeFragmentByTag"); + JVar tagParam = findNativeFragmentByTag.param(classes().STRING, "tag"); + + JBlock body = findNativeFragmentByTag.body(); + + body._if(getContextRef()._instanceof(classes().ACTIVITY).not())._then()._return(_null()); + + JVar activityVar = body.decl(classes().ACTIVITY, "activity_", cast(classes().ACTIVITY, getContextRef())); + + body._return(activityVar.invoke("getFragmentManager").invoke("findFragmentByTag").arg(tagParam)); + } + + public JMethod getFindSupportFragmentByTag() { + if (findSupportFragmentByTag == null) { + setFindSupportFragmentByTag(); + } + return findSupportFragmentByTag; + } + + protected void setFindSupportFragmentByTag() { + findSupportFragmentByTag = getGeneratedClass().method(PRIVATE, classes().SUPPORT_V4_FRAGMENT, "findSupportFragmentByTag"); + JVar tagParam = findSupportFragmentByTag.param(classes().STRING, "tag"); + + JBlock body = findSupportFragmentByTag.body(); + + body._if(getContextRef()._instanceof(classes().FRAGMENT_ACTIVITY).not())._then()._return(_null()); + + JVar activityVar = body.decl(classes().FRAGMENT_ACTIVITY, "activity_", cast(classes().FRAGMENT_ACTIVITY, getContextRef())); + + body._return(activityVar.invoke("getSupportFragmentManager").invoke("findFragmentByTag").arg(tagParam)); + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java index c8e6e1aefc..80ff60e2f0 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java @@ -1,31 +1,24 @@ package org.androidannotations.holder; import com.sun.codemodel.*; -import org.androidannotations.helper.FindFragmentHelper; +import org.androidannotations.helper.AnnotationHelper; import org.androidannotations.helper.HoloEverywhereHelper; -import org.androidannotations.helper.ViewNotifierHelper; +import org.androidannotations.helper.ThirdPartyLibHelper; import org.androidannotations.process.ProcessHolder; -import org.androidannotations.helper.*; import javax.lang.model.element.TypeElement; import static com.sun.codemodel.JExpr.*; import static com.sun.codemodel.JMod.*; -public class EFragmentHolder extends EComponentHolder implements HasViewChanged, HasInstanceState, HasOptionsMenu { +public class EFragmentHolder extends EComponentWithViewSupportHolder implements HasInstanceState, HasOptionsMenu { - private ViewNotifierHelper viewNotifierHelper; private JFieldVar contentView; private JBlock setContentViewBlock; private JVar inflater; private JVar container; private JDefinedClass fragmentBuilderClass; private JFieldVar fragmentArgumentsBuilderField; - private ViewChangedHolder viewChangedHolder; - private JMethod findNativeFragmentById; - private JMethod findSupportFragmentById; - private JMethod findNativeFragmentByTag; - private JMethod findSupportFragmentByTag; private JMethod injectArgsMethod; private JBlock injectArgsBlock; private JVar injectBundleArgs; @@ -39,7 +32,6 @@ public class EFragmentHolder extends EComponentHolder implements HasViewChanged, public EFragmentHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); - viewNotifierHelper = new ViewNotifierHelper(this); instanceStateHolder = new InstanceStateHolder(this); createOnCreate(); createOnViewCreated(); @@ -174,66 +166,6 @@ private void setContentView() { contentView = generatedClass.field(PRIVATE, classes().VIEW, "contentView_"); } - @Override - public ViewChangedHolder getOnViewChangedHolder() { - if (viewChangedHolder == null) { - setViewChangedHolder(); - } - return viewChangedHolder; - } - - private void setViewChangedHolder() { - viewChangedHolder = ViewChangedHolder.createViewChangedHolder(this); - } - - @Override - public JMethod getFindNativeFragmentById() { - if (findNativeFragmentById == null) { - setFindNativeFragmentById(); - } - return findNativeFragmentById; - } - - private void setFindNativeFragmentById() { - findNativeFragmentById = FindFragmentHelper.createFindNativeFragmentById(this); - } - - @Override - public JMethod getFindSupportFragmentById() { - if (findSupportFragmentById == null) { - setFindSupportFragmentById(); - } - return findSupportFragmentById; - } - - private void setFindSupportFragmentById() { - findSupportFragmentById = FindFragmentHelper.createFindSupportFragmentById(this); - } - - @Override - public JMethod getFindNativeFragmentByTag() { - if (findNativeFragmentByTag == null) { - setFindNativeFragmentByTag(); - } - return findNativeFragmentByTag; - } - - private void setFindNativeFragmentByTag() { - findNativeFragmentByTag = FindFragmentHelper.createFindNativeFragmentByTag(this); - } - - @Override - public JMethod getFindSupportFragmentByTag() { - if (findSupportFragmentByTag == null) { - setFindSupportFragmentByTag(); - } - return findSupportFragmentByTag; - } - - private void setFindSupportFragmentByTag() { - findSupportFragmentByTag = FindFragmentHelper.createFindSupportFragmentByTag(this); - } - private void setOnCreateView() { JMethod onCreateView = generatedClass.method(PUBLIC, classes().VIEW, "onCreateView"); onCreateView.annotate(Override.class); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java index 7c17fba59e..88fdc5fc55 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java @@ -1,9 +1,7 @@ package org.androidannotations.holder; import com.sun.codemodel.*; -import org.androidannotations.helper.FindFragmentHelper; import org.androidannotations.helper.ModelConstants; -import org.androidannotations.helper.ViewNotifierHelper; import org.androidannotations.process.ProcessHolder; import javax.lang.model.element.*; @@ -14,7 +12,7 @@ import static com.sun.codemodel.JMod.*; import static javax.lang.model.element.ElementKind.CONSTRUCTOR; -public class EViewHolder extends EComponentHolder implements HasViewChanged { +public class EViewHolder extends EComponentWithViewSupportHolder { protected static final String ALREADY_INFLATED_COMMENT = "" // + + "The mAlreadyInflated_ hack is needed because of an Android bug\n" // + @@ -30,18 +28,11 @@ public class EViewHolder extends EComponentHolder implements HasViewChanged { + "are in a View." // ; - protected ViewNotifierHelper viewNotifierHelper; protected JMethod onFinishInflate; protected JFieldVar alreadyInflated; - private ViewChangedHolder viewChangedHolder; - private JMethod findNativeFragmentById; - private JMethod findSupportFragmentById; - private JMethod findNativeFragmentByTag; - private JMethod findSupportFragmentByTag; public EViewHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); - viewNotifierHelper = new ViewNotifierHelper(this); addSuppressWarning(); createConstructorAndBuilder(); } @@ -140,64 +131,4 @@ public JFieldVar getAlreadyInflated() { private void setAlreadyInflated() { alreadyInflated = generatedClass.field(PRIVATE, JType.parse(codeModel(), "boolean"), "alreadyInflated_", JExpr.FALSE); } - - @Override - public ViewChangedHolder getOnViewChangedHolder() { - if (viewChangedHolder == null) { - setViewChangedHolder(); - } - return viewChangedHolder; - } - - private void setViewChangedHolder() { - viewChangedHolder = ViewChangedHolder.createViewChangedHolder(this); - } - - @Override - public JMethod getFindNativeFragmentById() { - if (findNativeFragmentById == null) { - setFindNativeFragmentById(); - } - return findNativeFragmentById; - } - - private void setFindNativeFragmentById() { - findNativeFragmentById = FindFragmentHelper.createFindNativeFragmentById(this); - } - - @Override - public JMethod getFindSupportFragmentById() { - if (findSupportFragmentById == null) { - setFindSupportFragmentById(); - } - return findSupportFragmentById; - } - - private void setFindSupportFragmentById() { - findSupportFragmentById = FindFragmentHelper.createFindSupportFragmentById(this); - } - - @Override - public JMethod getFindNativeFragmentByTag() { - if (findNativeFragmentByTag == null) { - setFindNativeFragmentByTag(); - } - return findNativeFragmentByTag; - } - - private void setFindNativeFragmentByTag() { - findNativeFragmentByTag = FindFragmentHelper.createFindNativeFragmentByTag(this); - } - - @Override - public JMethod getFindSupportFragmentByTag() { - if (findSupportFragmentByTag == null) { - setFindSupportFragmentByTag(); - } - return findSupportFragmentByTag; - } - - private void setFindSupportFragmentByTag() { - findSupportFragmentByTag = FindFragmentHelper.createFindSupportFragmentByTag(this); - } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasViewChanged.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasViewChanged.java deleted file mode 100644 index a22497a339..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasViewChanged.java +++ /dev/null @@ -1,13 +0,0 @@ -package org.androidannotations.holder; - -import com.sun.codemodel.JExpression; -import com.sun.codemodel.JMethod; - -public interface HasViewChanged extends GeneratedClassHolder { - ViewChangedHolder getOnViewChangedHolder(); - JMethod getFindNativeFragmentById(); - JMethod getFindSupportFragmentById(); - JMethod getFindNativeFragmentByTag(); - JMethod getFindSupportFragmentByTag(); - JExpression getContextRef(); -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/ViewChangedHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/ViewChangedHolder.java deleted file mode 100644 index f1a9e21f0b..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/ViewChangedHolder.java +++ /dev/null @@ -1,58 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.holder; - -import com.sun.codemodel.*; -import org.androidannotations.api.view.HasViews; -import org.androidannotations.api.view.OnViewChangedListener; -import org.androidannotations.api.view.OnViewChangedNotifier; - -import static com.sun.codemodel.JExpr._this; -import static com.sun.codemodel.JExpr.invoke; -import static com.sun.codemodel.JMod.PUBLIC; - -public class ViewChangedHolder { - - public static ViewChangedHolder createViewChangedHolder(EComponentHolder holder) { - holder.getGeneratedClass()._implements(OnViewChangedListener.class); - JMethod onViewChanged = holder.getGeneratedClass().method(PUBLIC, holder.codeModel().VOID, "onViewChanged"); - onViewChanged.annotate(Override.class); - JVar onViewChangedHasViewsParam = onViewChanged.param(HasViews.class, "hasViews"); - JClass notifierClass = holder.refClass(OnViewChangedNotifier.class); - holder.getInit().body().staticInvoke(notifierClass, "registerOnViewChangedListener").arg(_this()); - return new ViewChangedHolder(onViewChanged, onViewChangedHasViewsParam); - } - - private JMethod onViewChanged; - private JVar onViewChangedHasViewsParam; - - public ViewChangedHolder(JMethod onViewChanged, JVar onViewChangedHasViewsParam) { - this.onViewChanged = onViewChanged; - this.onViewChangedHasViewsParam = onViewChangedHasViewsParam; - } - - public JBlock body() { - return onViewChanged.body(); - } - - public JInvocation findViewById(JFieldRef idRef) { - JInvocation findViewById = invoke(onViewChangedHasViewsParam, "findViewById"); - findViewById.arg(idRef); - return findViewById; - - } - -} From ba173b903ffce76c8a2cb268fd38e105f0422f9f Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 6 Jun 2013 10:06:06 +0200 Subject: [PATCH 54/86] Implement BeforeTextChangeHandler --- .../handler/AnnotationHandlers.java | 2 + .../handler/BeforeTextChangeHandler.java | 124 ++++++++++++++++++ .../helper/ValidatorHelper.java | 36 +++++ .../EComponentWithViewSupportHolder.java | 34 +++++ .../holder/TextWatcherHolder.java | 112 ++++++++++++++++ 5 files changed, 308 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeforeTextChangeHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/TextWatcherHolder.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 8f118d921f..66fef48d5a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -1,5 +1,6 @@ package org.androidannotations.handler; +import org.androidannotations.annotations.BeforeTextChange; import org.androidannotations.handler.rest.GetHandler; import org.androidannotations.handler.rest.RestHandler; import org.androidannotations.helper.AndroidManifest; @@ -71,6 +72,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new RootContextHanlder(processingEnvironment)); add(new NonConfigurationInstanceHandler(processingEnvironment)); add(new BeanHandler(processingEnvironment)); + add(new BeforeTextChangeHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeforeTextChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeforeTextChangeHandler.java new file mode 100644 index 0000000000..7f7feaf0c9 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeforeTextChangeHandler.java @@ -0,0 +1,124 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.BeforeTextChange; +import org.androidannotations.helper.AndroidManifest; +import org.androidannotations.helper.CanonicalNameConstants; +import org.androidannotations.helper.IdAnnotationHelper; +import org.androidannotations.helper.IdValidatorHelper; +import org.androidannotations.holder.EComponentWithViewSupportHolder; +import org.androidannotations.holder.TextWatcherHolder; +import org.androidannotations.model.AndroidSystemServices; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.rclass.IRClass; +import org.androidannotations.validation.IsValid; + +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 java.util.List; + +public class BeforeTextChangeHandler extends BaseAnnotationHandler { + + private IdAnnotationHelper idAnnotationHelper; + + public BeforeTextChangeHandler(ProcessingEnvironment processingEnvironment) { + super(BeforeTextChange.class, processingEnvironment); + } + + @Override + public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) { + super.setAndroidEnvironment(rClass, androidSystemServices, androidManifest); + idAnnotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); + + validatorHelper.resIdsExist(element, IRClass.Res.ID, IdValidatorHelper.FallbackStrategy.USE_ELEMENT_NAME, valid); + + validatorHelper.isNotPrivate(element, valid); + + validatorHelper.doesntThrowException(element, valid); + + validatorHelper.returnTypeIsVoid((ExecutableElement) element, valid); + + validatorHelper.hasBeforeTextChangedMethodParameters((ExecutableElement) element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EComponentWithViewSupportHolder holder) throws Exception { + String methodName = element.getSimpleName().toString(); + + ExecutableElement executableElement = (ExecutableElement) element; + List parameters = executableElement.getParameters(); + + int startParameterPosition = -1; + int countParameterPosition = -1; + int afterParameterPosition = -1; + int charSequenceParameterPosition = -1; + int viewParameterPosition = -1; + TypeMirror viewParameterType = null; + + for (int i = 0; i < parameters.size(); i++) { + VariableElement parameter = parameters.get(i); + String parameterName = parameter.toString(); + TypeMirror parameterType = parameter.asType(); + + if (CanonicalNameConstants.CHAR_SEQUENCE.equals(parameterType.toString())) { + charSequenceParameterPosition = i; + } else if (parameterType.getKind() == TypeKind.INT || CanonicalNameConstants.INTEGER.equals(parameterType.toString())) { + if ("start".equals(parameterName)) { + startParameterPosition = i; + } else if ("count".equals(parameterName)) { + countParameterPosition = i; + } else if ("after".equals(parameterName)) { + afterParameterPosition = i; + } + } else { + TypeMirror textViewType = idAnnotationHelper.typeElementFromQualifiedName(CanonicalNameConstants.TEXT_VIEW).asType(); + if (idAnnotationHelper.isSubtype(parameterType, textViewType)) { + viewParameterPosition = i; + viewParameterType = parameterType; + } + } + } + + List idsRefs = idAnnotationHelper.extractAnnotationFieldRefs(holder, element, IRClass.Res.ID, true); + + for (JFieldRef idRef : idsRefs) { + TextWatcherHolder textWatcherHolder = holder.getTextWatcherHolder(idRef, viewParameterType); + JBlock methodBody = textWatcherHolder.getBeforeTextChangedBody(); + + JExpression activityRef = holder.getGeneratedClass().staticRef("this"); + JInvocation textChangeCall = methodBody.invoke(activityRef, methodName); + + for (int i = 0; i < parameters.size(); i++) { + if (i == startParameterPosition) { + JVar startParameter = textWatcherHolder.getBeforeTextChangedStartParam(); + textChangeCall.arg(startParameter); + } else if (i == countParameterPosition) { + JVar countParameter = textWatcherHolder.getBeforeTextChangedCountParam(); + textChangeCall.arg(countParameter); + } else if (i == afterParameterPosition) { + JVar afterParameter = textWatcherHolder.getBeforeTextChangedAfterParam(); + textChangeCall.arg(afterParameter); + } else if (i == charSequenceParameterPosition) { + JVar charSequenceParam = textWatcherHolder.getBeforeTextChangedCharSequenceParam(); + textChangeCall.arg(charSequenceParam); + } else if (i == viewParameterPosition) { + JVar viewParameter = textWatcherHolder.getTextViewVariable(); + textChangeCall.arg(viewParameter); + } + } + } + } +} 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 f1c9a1ae8b..a830a6d373 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java @@ -1089,4 +1089,40 @@ public void validateInterceptors(Element element, IsValid valid) { } } + public void hasBeforeTextChangedMethodParameters(ExecutableElement executableElement, IsValid valid) { + List parameters = executableElement.getParameters(); + boolean charSequenceParameterFound = false; + boolean textViewParameterFound = false; + for (VariableElement parameter : parameters) { + String parameterType = parameter.asType().toString(); + if (parameterType.equals(CanonicalNameConstants.CHAR_SEQUENCE)) { + if (charSequenceParameterFound) { + annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter declaration. you can declare only one parameter of type java.lang.CharSequence"); + valid.invalidate(); + } + charSequenceParameterFound = true; + continue; + } + if (parameterType.equals(CanonicalNameConstants.TEXT_VIEW)) { + if (textViewParameterFound) { + annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter declaration. you can declare only one parameter of type android.widget.TextView"); + valid.invalidate(); + } + textViewParameterFound = true; + continue; + } + if (parameter.asType().getKind() == TypeKind.INT || CanonicalNameConstants.INTEGER.equals(parameterType)) { + String parameterName = parameter.toString(); + if ("start".equals(parameterName) || "count".equals(parameterName) || "after".equals(parameterName)) { + continue; + } + annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter name. You can only have start, before, or count parameter name. Try to pick a parameter from android.text.TextWatcher.beforeTextChanged() method."); + valid.invalidate(); + continue; + } + annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter (" + parameter.toString() + "). %s can only have a android.widget.TextView parameter and/or parameters from android.text.TextWatcher.beforeTextChanged() method."); + valid.invalidate(); + } + } + } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentWithViewSupportHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentWithViewSupportHolder.java index f19ec1d026..eb4025e199 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentWithViewSupportHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentWithViewSupportHolder.java @@ -4,17 +4,24 @@ import org.androidannotations.api.view.HasViews; import org.androidannotations.api.view.OnViewChangedListener; import org.androidannotations.api.view.OnViewChangedNotifier; +import org.androidannotations.helper.APTCodeModelHelper; import org.androidannotations.helper.ViewNotifierHelper; import org.androidannotations.process.ProcessHolder; import javax.lang.model.element.TypeElement; +import javax.lang.model.type.TypeMirror; + +import java.util.HashMap; import static com.sun.codemodel.JExpr.*; +import static com.sun.codemodel.JExpr._new; +import static com.sun.codemodel.JMod.FINAL; import static com.sun.codemodel.JMod.PRIVATE; import static com.sun.codemodel.JMod.PUBLIC; public abstract class EComponentWithViewSupportHolder extends EComponentHolder { + private APTCodeModelHelper codeModelHelper; protected ViewNotifierHelper viewNotifierHelper; private JBlock onViewChangedBody; private JVar onViewChangedHasViewsParam; @@ -22,9 +29,11 @@ public abstract class EComponentWithViewSupportHolder extends EComponentHolder { protected JMethod findSupportFragmentById; protected JMethod findNativeFragmentByTag; protected JMethod findSupportFragmentByTag; + private HashMap textWatcherHolders = new HashMap(); public EComponentWithViewSupportHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); + codeModelHelper = new APTCodeModelHelper(); viewNotifierHelper = new ViewNotifierHelper(this); } @@ -137,4 +146,29 @@ protected void setFindSupportFragmentByTag() { body._return(activityVar.invoke("getSupportFragmentManager").invoke("findFragmentByTag").arg(tagParam)); } + + public TextWatcherHolder getTextWatcherHolder(JFieldRef idRef, TypeMirror viewParameterType) { + String idRefString = codeModelHelper.getIdStringFromIdFieldRef(idRef); + TextWatcherHolder textWatcherHolder = textWatcherHolders.get(idRefString); + if (textWatcherHolder == null) { + textWatcherHolder = createTextWatcherHolder(idRef, viewParameterType); + textWatcherHolders.put(idRefString, textWatcherHolder); + } + return textWatcherHolder; + } + + private TextWatcherHolder createTextWatcherHolder(JFieldRef idRef, TypeMirror viewParameterType) { + JDefinedClass onTextChangeListenerClass = codeModel().anonymousClass(classes().TEXT_WATCHER); + JClass viewClass = classes().TEXT_VIEW; + if (viewParameterType != null) { + viewClass = refClass(viewParameterType.toString()); + } + + JBlock onViewChangedBody = getOnViewChangedBody().block(); + JVar viewVariable = onViewChangedBody.decl(FINAL, viewClass, "view", cast(viewClass, findViewById(idRef))); + onViewChangedBody._if(viewVariable.ne(JExpr._null()))._then() // + .invoke(viewVariable, "addTextChangedListener").arg(_new(onTextChangeListenerClass)); + + return new TextWatcherHolder(this, viewVariable, onTextChangeListenerClass); + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/TextWatcherHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/TextWatcherHolder.java new file mode 100644 index 0000000000..6dda6b0506 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/TextWatcherHolder.java @@ -0,0 +1,112 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.*; + +public class TextWatcherHolder { + + private EComponentWithViewSupportHolder holder; + private JVar textViewVariable; + private JDefinedClass listenerClass; + private JBlock beforeTextChangedBody; + private JVar beforeTextChangedCharSequenceParam; + private JVar beforeTextChangedStartParam; + private JVar beforeTextChangedCountParam; + private JVar beforeTextChangedAfterParam; + private JBlock onTextChangedBody; + private JVar onTextChangedCharSequenceParam; + private JVar onTextChangedStartParam; + private JVar onTextChangedBeforeParam; + private JVar onTextChangedCountParam; + private JBlock afterTextChangedBody; + private JVar afterTextChangedEditableParam; + + public TextWatcherHolder(EComponentWithViewSupportHolder holder, JVar viewVariable, JDefinedClass onTextChangeListenerClass) { + this.holder = holder; + this.textViewVariable = viewVariable; + this.listenerClass = onTextChangeListenerClass; + createBeforeTextChanged(); + createOnTextChanged(); + createAfterTextChanged(); + } + + private void createBeforeTextChanged() { + JPrimitiveType intClass = holder.codeModel().INT; + JMethod beforeTextChangedMethod = listenerClass.method(JMod.PUBLIC, holder.codeModel().VOID, "beforeTextChanged"); + beforeTextChangedMethod.annotate(Override.class); + beforeTextChangedBody = beforeTextChangedMethod.body(); + beforeTextChangedCharSequenceParam = beforeTextChangedMethod.param(holder.classes().CHAR_SEQUENCE, "s"); + beforeTextChangedStartParam = beforeTextChangedMethod.param(intClass, "start"); + beforeTextChangedCountParam = beforeTextChangedMethod.param(intClass, "count"); + beforeTextChangedAfterParam = beforeTextChangedMethod.param(intClass, "after"); + } + + private void createOnTextChanged() { + JPrimitiveType intClass = holder.codeModel().INT; + JMethod onTextChangedMethod = listenerClass.method(JMod.PUBLIC, holder.codeModel().VOID, "onTextChanged"); + onTextChangedMethod.annotate(Override.class); + onTextChangedBody = onTextChangedMethod.body(); + onTextChangedCharSequenceParam = onTextChangedMethod.param(holder.classes().CHAR_SEQUENCE, "s"); + onTextChangedStartParam = onTextChangedMethod.param(intClass, "start"); + onTextChangedBeforeParam = onTextChangedMethod.param(intClass, "before"); + onTextChangedCountParam = onTextChangedMethod.param(intClass, "count"); + } + + private void createAfterTextChanged() { + JMethod afterTextChangedMethod = listenerClass.method(JMod.PUBLIC, holder.codeModel().VOID, "afterTextChanged"); + afterTextChangedMethod.annotate(Override.class); + afterTextChangedBody = afterTextChangedMethod.body(); + afterTextChangedEditableParam = afterTextChangedMethod.param(holder.classes().EDITABLE, "s"); + } + + public JVar getTextViewVariable() { + return textViewVariable; + } + + public JBlock getBeforeTextChangedBody() { + return beforeTextChangedBody; + } + + public JVar getBeforeTextChangedCharSequenceParam() { + return beforeTextChangedCharSequenceParam; + } + + public JVar getBeforeTextChangedStartParam() { + return beforeTextChangedStartParam; + } + + public JVar getBeforeTextChangedCountParam() { + return beforeTextChangedCountParam; + } + + public JVar getBeforeTextChangedAfterParam() { + return beforeTextChangedAfterParam; + } + + public JBlock getOnTextChangedBody() { + return onTextChangedBody; + } + + public JVar getOnTextChangedCharSequenceParam() { + return onTextChangedCharSequenceParam; + } + + public JVar getOnTextChangedStartParam() { + return onTextChangedStartParam; + } + + public JVar getOnTextChangedBeforeParam() { + return onTextChangedBeforeParam; + } + + public JVar getOnTextChangedCountParam() { + return onTextChangedCountParam; + } + + public JBlock getAfterTextChangedBody() { + return afterTextChangedBody; + } + + public JVar getAfterTextChangedEditableParam() { + return afterTextChangedEditableParam; + } +} From 3c94932dbccea5b3f91f9fb173816cd8f0cd06a1 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 6 Jun 2013 11:01:49 +0200 Subject: [PATCH 55/86] Implement TextChangeHandler --- .../handler/AnnotationHandlers.java | 2 +- .../handler/TextChangeHandler.java | 125 ++++++++++++++++++ .../helper/ValidatorHelper.java | 36 +++++ 3 files changed, 162 insertions(+), 1 deletion(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TextChangeHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 66fef48d5a..3dbff5785e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -1,6 +1,5 @@ package org.androidannotations.handler; -import org.androidannotations.annotations.BeforeTextChange; import org.androidannotations.handler.rest.GetHandler; import org.androidannotations.handler.rest.RestHandler; import org.androidannotations.helper.AndroidManifest; @@ -73,6 +72,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new NonConfigurationInstanceHandler(processingEnvironment)); add(new BeanHandler(processingEnvironment)); add(new BeforeTextChangeHandler(processingEnvironment)); + add(new TextChangeHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TextChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TextChangeHandler.java new file mode 100644 index 0000000000..60e87358e4 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TextChangeHandler.java @@ -0,0 +1,125 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.TextChange; +import org.androidannotations.helper.AndroidManifest; +import org.androidannotations.helper.CanonicalNameConstants; +import org.androidannotations.helper.IdAnnotationHelper; +import org.androidannotations.helper.IdValidatorHelper; +import org.androidannotations.holder.EComponentWithViewSupportHolder; +import org.androidannotations.holder.TextWatcherHolder; +import org.androidannotations.model.AndroidSystemServices; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.rclass.IRClass; +import org.androidannotations.validation.IsValid; + +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 java.util.List; + +public class TextChangeHandler extends BaseAnnotationHandler { + + private IdAnnotationHelper idAnnotationHelper; + + public TextChangeHandler(ProcessingEnvironment processingEnvironment) { + super(TextChange.class, processingEnvironment); + } + + @Override + public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) { + super.setAndroidEnvironment(rClass, androidSystemServices, androidManifest); + idAnnotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); + + validatorHelper.resIdsExist(element, IRClass.Res.ID, IdValidatorHelper.FallbackStrategy.USE_ELEMENT_NAME, valid); + + validatorHelper.isNotPrivate(element, valid); + + validatorHelper.doesntThrowException(element, valid); + + validatorHelper.returnTypeIsVoid((ExecutableElement) element, valid); + + validatorHelper.hasTextChangedMethodParameters((ExecutableElement) element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EComponentWithViewSupportHolder holder) throws Exception { + String methodName = element.getSimpleName().toString(); + + ExecutableElement executableElement = (ExecutableElement) element; + List parameters = executableElement.getParameters(); + + int startParameterPosition = -1; + int countParameterPosition = -1; + int beforeParameterPosition = -1; + int charSequenceParameterPosition = -1; + int viewParameterPosition = -1; + TypeMirror viewParameterType = null; + + for (int i = 0; i < parameters.size(); i++) { + VariableElement parameter = parameters.get(i); + String parameterName = parameter.toString(); + TypeMirror parameterType = parameter.asType(); + + if (CanonicalNameConstants.CHAR_SEQUENCE.equals(parameterType.toString())) { + charSequenceParameterPosition = i; + } else if (parameterType.getKind() == TypeKind.INT || CanonicalNameConstants.INTEGER.equals(parameterType.toString())) { + if ("start".equals(parameterName)) { + startParameterPosition = i; + } else if ("count".equals(parameterName)) { + countParameterPosition = i; + } else if ("before".equals(parameterName)) { + beforeParameterPosition = i; + } + } else { + TypeMirror textViewType = idAnnotationHelper.typeElementFromQualifiedName(CanonicalNameConstants.TEXT_VIEW).asType(); + if (idAnnotationHelper.isSubtype(parameterType, textViewType)) { + viewParameterPosition = i; + viewParameterType = parameterType; + } + } + } + + List idsRefs = idAnnotationHelper.extractAnnotationFieldRefs(holder, element, IRClass.Res.ID, true); + + for (JFieldRef idRef : idsRefs) { + TextWatcherHolder textWatcherHolder = holder.getTextWatcherHolder(idRef, viewParameterType); + JBlock methodBody = textWatcherHolder.getOnTextChangedBody(); + + JExpression activityRef = holder.getGeneratedClass().staticRef("this"); + JInvocation textChangeCall = methodBody.invoke(activityRef, methodName); + + for (int i = 0; i < parameters.size(); i++) { + if (i == startParameterPosition) { + JVar startParameter = textWatcherHolder.getOnTextChangedStartParam(); + textChangeCall.arg(startParameter); + } else if (i == countParameterPosition) { + JVar countParameter = textWatcherHolder.getOnTextChangedCountParam(); + textChangeCall.arg(countParameter); + } else if (i == beforeParameterPosition) { + JVar beforeParameter = textWatcherHolder.getOnTextChangedBeforeParam(); + textChangeCall.arg(beforeParameter); + } else if (i == charSequenceParameterPosition) { + JVar charSequenceParam = textWatcherHolder.getOnTextChangedCharSequenceParam(); + textChangeCall.arg(charSequenceParam); + } else if (i == viewParameterPosition) { + JVar viewParameter = textWatcherHolder.getTextViewVariable(); + textChangeCall.arg(viewParameter); + } + } + + } + } +} 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 a830a6d373..9f3de9120e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java @@ -1125,4 +1125,40 @@ public void hasBeforeTextChangedMethodParameters(ExecutableElement executableEle } } + public void hasTextChangedMethodParameters(ExecutableElement executableElement, IsValid valid) { + List parameters = executableElement.getParameters(); + boolean charSequenceParameterFound = false; + boolean textViewParameterFound = false; + for (VariableElement parameter : parameters) { + String parameterType = parameter.asType().toString(); + if (parameterType.equals(CanonicalNameConstants.CHAR_SEQUENCE)) { + if (charSequenceParameterFound) { + annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter declaration. you can declare only one parameter of type java.lang.CharSequence"); + valid.invalidate(); + } + charSequenceParameterFound = true; + continue; + } + if (parameterType.equals(CanonicalNameConstants.TEXT_VIEW)) { + if (textViewParameterFound) { + annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter declaration. you can declare only one parameter of type android.widget.TextView"); + valid.invalidate(); + } + textViewParameterFound = true; + continue; + } + if (parameter.asType().getKind() == TypeKind.INT || CanonicalNameConstants.INTEGER.equals(parameterType)) { + String parameterName = parameter.toString(); + if ("start".equals(parameterName) || "before".equals(parameterName) || "count".equals(parameterName)) { + continue; + } + annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter name. You can only have start, before, or count parameter name. Try to pick a prameter from the android.text.TextWatcher.onTextChanged() method."); + valid.invalidate(); + continue; + } + annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter (" + parameter.toString() + "). %s can only have a android.widget.TextView parameter and/or parameters from android.text.TextWatcher.onTextChanged() method."); + valid.invalidate(); + } + } + } From 3bf319d8ff18a252517779b7ecdc6afbed3816c5 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 6 Jun 2013 11:10:36 +0200 Subject: [PATCH 56/86] Implement AfterTextChangeHandler --- .../handler/AfterTextChangeHandler.java | 103 ++++++++++++++++++ .../handler/AnnotationHandlers.java | 1 + .../helper/ValidatorHelper.java | 27 +++++ 3 files changed, 131 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterTextChangeHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterTextChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterTextChangeHandler.java new file mode 100644 index 0000000000..bd37a20524 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterTextChangeHandler.java @@ -0,0 +1,103 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.AfterTextChange; +import org.androidannotations.helper.AndroidManifest; +import org.androidannotations.helper.CanonicalNameConstants; +import org.androidannotations.helper.IdAnnotationHelper; +import org.androidannotations.helper.IdValidatorHelper; +import org.androidannotations.holder.EComponentWithViewSupportHolder; +import org.androidannotations.holder.TextWatcherHolder; +import org.androidannotations.model.AndroidSystemServices; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.rclass.IRClass; +import org.androidannotations.validation.IsValid; + +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 java.util.List; + +public class AfterTextChangeHandler extends BaseAnnotationHandler { + + private IdAnnotationHelper idAnnotationHelper; + + public AfterTextChangeHandler(ProcessingEnvironment processingEnvironment) { + super(AfterTextChange.class, processingEnvironment); + } + + @Override + public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) { + super.setAndroidEnvironment(rClass, androidSystemServices, androidManifest); + idAnnotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); + } + + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); + + validatorHelper.resIdsExist(element, IRClass.Res.ID, IdValidatorHelper.FallbackStrategy.USE_ELEMENT_NAME, valid); + + validatorHelper.isNotPrivate(element, valid); + + validatorHelper.doesntThrowException(element, valid); + + validatorHelper.returnTypeIsVoid((ExecutableElement) element, valid); + + validatorHelper.hasAfterTextChangedMethodParameters((ExecutableElement) element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EComponentWithViewSupportHolder holder) throws Exception { + String methodName = element.getSimpleName().toString(); + + ExecutableElement executableElement = (ExecutableElement) element; + List parameters = executableElement.getParameters(); + + int editableParameterPosition = -1; + int viewParameterPosition = -1; + TypeMirror viewParameterType = null; + + for (int i = 0; i < parameters.size(); i++) { + VariableElement parameter = parameters.get(i); + TypeMirror parameterType = parameter.asType(); + + if (CanonicalNameConstants.EDITABLE.equals(parameterType.toString())) { + editableParameterPosition = i; + } else { + TypeMirror textViewType = idAnnotationHelper.typeElementFromQualifiedName(CanonicalNameConstants.TEXT_VIEW).asType(); + if (idAnnotationHelper.isSubtype(parameterType, textViewType)) { + viewParameterPosition = i; + viewParameterType = parameterType; + } + } + } + + List idsRefs = idAnnotationHelper.extractAnnotationFieldRefs(holder, element, IRClass.Res.ID, true); + + for (JFieldRef idRef : idsRefs) { + TextWatcherHolder textWatcherHolder = holder.getTextWatcherHolder(idRef, viewParameterType); + JBlock methodBody = textWatcherHolder.getAfterTextChangedBody(); + + JExpression activityRef = holder.getGeneratedClass().staticRef("this"); + JInvocation textChangeCall = methodBody.invoke(activityRef, methodName); + + for (int i = 0; i < parameters.size(); i++) { + if (i == editableParameterPosition) { + JVar afterTextChangeEditableParam = textWatcherHolder.getAfterTextChangedEditableParam(); + textChangeCall.arg(afterTextChangeEditableParam); + } else if (i == viewParameterPosition) { + JVar viewParameter = textWatcherHolder.getTextViewVariable(); + textChangeCall.arg(viewParameter); + } + } + } + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 3dbff5785e..3bca524a17 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -73,6 +73,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new BeanHandler(processingEnvironment)); add(new BeforeTextChangeHandler(processingEnvironment)); add(new TextChangeHandler(processingEnvironment)); + add(new AfterTextChangeHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); 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 9f3de9120e..fc3fe1be5f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java @@ -1161,4 +1161,31 @@ public void hasTextChangedMethodParameters(ExecutableElement executableElement, } } + public void hasAfterTextChangedMethodParameters(ExecutableElement executableElement, IsValid valid) { + List parameters = executableElement.getParameters(); + boolean editableParameterFound = false; + boolean textViewParameterFound = false; + for (VariableElement parameter : parameters) { + String parameterType = parameter.asType().toString(); + if (parameterType.equals(CanonicalNameConstants.EDITABLE)) { + if (editableParameterFound) { + annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter declaration. you can declare only one parameter of type android.text.Editable"); + valid.invalidate(); + } + editableParameterFound = true; + continue; + } + if (parameterType.equals(CanonicalNameConstants.TEXT_VIEW)) { + if (textViewParameterFound) { + annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter declaration. you can declare only one parameter of type android.widget.TextView"); + valid.invalidate(); + } + textViewParameterFound = true; + continue; + } + valid.invalidate(); + annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter type. %s can only have a android.widget.TextView parameter and/or an android.text.Editable parameter. See android.text.TextWatcher.afterTextChanged() for more informations."); + } + } + } From 140be6ab8e6acdc0d262d28b43a686f3784602ed Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 6 Jun 2013 11:52:19 +0200 Subject: [PATCH 57/86] Implement SeekBarProgressChangeHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/SeekBarProgressChangeHandler.java | 105 ++++++++++++++++++ .../helper/ValidatorHelper.java | 36 ++++++ .../EComponentWithViewSupportHolder.java | 29 ++++- .../holder/OnSeekBarChangeListenerHolder.java | 80 +++++++++++++ 5 files changed, 246 insertions(+), 5 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarProgressChangeHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/OnSeekBarChangeListenerHolder.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 3bca524a17..84ae779074 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -74,6 +74,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new BeforeTextChangeHandler(processingEnvironment)); add(new TextChangeHandler(processingEnvironment)); add(new AfterTextChangeHandler(processingEnvironment)); + add(new SeekBarProgressChangeHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarProgressChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarProgressChangeHandler.java new file mode 100644 index 0000000000..01d37bb350 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarProgressChangeHandler.java @@ -0,0 +1,105 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.SeekBarProgressChange; +import org.androidannotations.helper.AndroidManifest; +import org.androidannotations.helper.CanonicalNameConstants; +import org.androidannotations.helper.IdAnnotationHelper; +import org.androidannotations.helper.IdValidatorHelper; +import org.androidannotations.holder.EComponentWithViewSupportHolder; +import org.androidannotations.holder.OnSeekBarChangeListenerHolder; +import org.androidannotations.model.AndroidSystemServices; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.rclass.IRClass; +import org.androidannotations.validation.IsValid; + +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 java.util.List; + +public class SeekBarProgressChangeHandler extends BaseAnnotationHandler { + + private IdAnnotationHelper annotationHelper; + + public SeekBarProgressChangeHandler(ProcessingEnvironment processingEnvironment) { + super(SeekBarProgressChange.class, processingEnvironment); + } + + @Override + public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) { + super.setAndroidEnvironment(rClass, androidSystemServices, androidManifest); + annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); + + validatorHelper.resIdsExist(element, IRClass.Res.ID, IdValidatorHelper.FallbackStrategy.USE_ELEMENT_NAME, valid); + + validatorHelper.isNotPrivate(element, valid); + + validatorHelper.doesntThrowException(element, valid); + + validatorHelper.returnTypeIsVoid((ExecutableElement) element, valid); + + validatorHelper.hasSeekBarProgressChangeMethodParameters((ExecutableElement) element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EComponentWithViewSupportHolder holder) throws Exception { + String methodName = element.getSimpleName().toString(); + + ExecutableElement executableElement = (ExecutableElement) element; + List parameters = executableElement.getParameters(); + + int seekBarViewParameterPosition = -1; + int progressParameterPosition = -1; + int fromUserParameterPosition = -1; + + for (int i = 0; i < parameters.size(); i++) { + VariableElement parameter = parameters.get(i); + TypeMirror parameterType = parameter.asType(); + + if (CanonicalNameConstants.SEEKBAR.equals(parameterType.toString())) { + seekBarViewParameterPosition = i; + } else if (parameterType.getKind() == TypeKind.INT || CanonicalNameConstants.INTEGER.equals(parameterType.toString())) { + progressParameterPosition = i; + } else if (parameterType.getKind() == TypeKind.BOOLEAN || CanonicalNameConstants.BOOLEAN.equals(parameterType.toString())) { + fromUserParameterPosition = i; + } + } + + List idsRefs = annotationHelper.extractAnnotationFieldRefs(holder, element, IRClass.Res.ID, true); + + for (JFieldRef idRef : idsRefs) { + OnSeekBarChangeListenerHolder onSeekBarChangeListenerHolder = holder.getOnSeekBarChangeListenerHolder(idRef); + JBlock methodBody = onSeekBarChangeListenerHolder.getOnProgressChangedBody(); + + JExpression activityRef = holder.getGeneratedClass().staticRef("this"); + JInvocation textChangeCall = methodBody.invoke(activityRef, methodName); + + for (int i = 0; i < parameters.size(); i++) { + if (i == seekBarViewParameterPosition) { + JVar seekBarViewParameter = onSeekBarChangeListenerHolder.getOnProgressChangedSeekBarParam(); + textChangeCall.arg(seekBarViewParameter); + } else if (i == progressParameterPosition) { + JVar progressParameter = onSeekBarChangeListenerHolder.getOnProgressChangedProgressParam(); + textChangeCall.arg(progressParameter); + } else if (i == fromUserParameterPosition) { + JVar fromUserParameter = onSeekBarChangeListenerHolder.getOnProgressChangedFromUserParam(); + textChangeCall.arg(fromUserParameter); + } + } + + } + } +} 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 fc3fe1be5f..1eac2d0026 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java @@ -1188,4 +1188,40 @@ public void hasAfterTextChangedMethodParameters(ExecutableElement executableElem } } + public void hasSeekBarProgressChangeMethodParameters(ExecutableElement executableElement, IsValid valid) { + List parameters = executableElement.getParameters(); + boolean seekBarParameterFound = false; + boolean fromUserParameterFound = false; + boolean progressParameterFound = false; + for (VariableElement parameter : parameters) { + String parameterType = parameter.asType().toString(); + if (parameterType.equals(CanonicalNameConstants.SEEKBAR)) { + if (seekBarParameterFound) { + annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter declaration. You can declare only one parameter of type " + CanonicalNameConstants.SEEKBAR); + valid.invalidate(); + } + seekBarParameterFound = true; + continue; + } + if (parameter.asType().getKind() == TypeKind.INT || CanonicalNameConstants.INTEGER.equals(parameterType)) { + if (progressParameterFound) { + annotationHelper.printAnnotationError(executableElement, "You can have only one parameter of type " + CanonicalNameConstants.INTEGER); + valid.invalidate(); + } + progressParameterFound = true; + continue; + } + if (parameter.asType().getKind() == TypeKind.BOOLEAN || CanonicalNameConstants.BOOLEAN.equals(parameterType)) { + if (fromUserParameterFound) { + annotationHelper.printAnnotationError(executableElement, "You can have only one parameter of type " + CanonicalNameConstants.BOOLEAN); + valid.invalidate(); + } + fromUserParameterFound = true; + continue; + } + annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter '" + parameter.toString() + "'. %s signature should be " + executableElement.getSimpleName() + "(" + CanonicalNameConstants.SEEKBAR + " seekBar, int progress, boolean fromUser). The 'fromUser' and 'progress' parameters are optional."); + valid.invalidate(); + } + } + } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentWithViewSupportHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentWithViewSupportHolder.java index eb4025e199..66fac8ee69 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentWithViewSupportHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentWithViewSupportHolder.java @@ -10,14 +10,10 @@ import javax.lang.model.element.TypeElement; import javax.lang.model.type.TypeMirror; - import java.util.HashMap; import static com.sun.codemodel.JExpr.*; -import static com.sun.codemodel.JExpr._new; -import static com.sun.codemodel.JMod.FINAL; -import static com.sun.codemodel.JMod.PRIVATE; -import static com.sun.codemodel.JMod.PUBLIC; +import static com.sun.codemodel.JMod.*; public abstract class EComponentWithViewSupportHolder extends EComponentHolder { @@ -30,6 +26,7 @@ public abstract class EComponentWithViewSupportHolder extends EComponentHolder { protected JMethod findNativeFragmentByTag; protected JMethod findSupportFragmentByTag; private HashMap textWatcherHolders = new HashMap(); + private HashMap onSeekBarChangeListenerHolders = new HashMap(); public EComponentWithViewSupportHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); @@ -171,4 +168,26 @@ private TextWatcherHolder createTextWatcherHolder(JFieldRef idRef, TypeMirror vi return new TextWatcherHolder(this, viewVariable, onTextChangeListenerClass); } + + public OnSeekBarChangeListenerHolder getOnSeekBarChangeListenerHolder(JFieldRef idRef) { + String idRefString = codeModelHelper.getIdStringFromIdFieldRef(idRef); + OnSeekBarChangeListenerHolder onSeekBarChangeListenerHolder = onSeekBarChangeListenerHolders.get(idRefString); + if (onSeekBarChangeListenerHolder == null) { + onSeekBarChangeListenerHolder = createOnSeekBarChangeListenerHolder(idRef); + onSeekBarChangeListenerHolders.put(idRefString, onSeekBarChangeListenerHolder); + } + return onSeekBarChangeListenerHolder; + } + + private OnSeekBarChangeListenerHolder createOnSeekBarChangeListenerHolder(JFieldRef idRef) { + JDefinedClass onSeekbarChangeListenerClass = codeModel().anonymousClass(classes().ON_SEEKBAR_CHANGE_LISTENER); + JClass viewClass = classes().SEEKBAR; + + JBlock onViewChangedBody = getOnViewChangedBody().block(); + JVar viewVariable = onViewChangedBody.decl(FINAL, viewClass, "view", cast(viewClass, findViewById(idRef))); + onViewChangedBody._if(viewVariable.ne(JExpr._null()))._then() // + .invoke(viewVariable, "setOnSeekBarChangeListener").arg(_new(onSeekbarChangeListenerClass)); + + return new OnSeekBarChangeListenerHolder(this, onSeekbarChangeListenerClass); + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/OnSeekBarChangeListenerHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/OnSeekBarChangeListenerHolder.java new file mode 100644 index 0000000000..b7a94e44d2 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/OnSeekBarChangeListenerHolder.java @@ -0,0 +1,80 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.*; + +public class OnSeekBarChangeListenerHolder { + + private EComponentWithViewSupportHolder holder; + private JDefinedClass listenerClass; + private JBlock onProgressChangedBody; + private JVar onProgressChangedSeekBarParam; + private JVar onProgressChangedProgressParam; + private JVar onProgressChangedFromUserParam; + private JBlock onStartTrackingTouchBody; + private JVar onStartTrackingTouchSeekBarParam; + private JBlock onStopTrackingTouchBody; + private JVar onStopTrackingTouchSeekBarParam; + + public OnSeekBarChangeListenerHolder(EComponentWithViewSupportHolder holder, JDefinedClass onSeekbarChangeListenerClass) { + this.holder = holder; + this.listenerClass = onSeekbarChangeListenerClass; + createOnProgressChanged(); + createOnStartTrackingTouch(); + createOnStopTrackingTouch(); + } + + private void createOnProgressChanged() { + JMethod onProgressChangedMethod = listenerClass.method(JMod.PUBLIC, holder.codeModel().VOID, "onProgressChanged"); + onProgressChangedMethod.annotate(Override.class); + onProgressChangedBody = onProgressChangedMethod.body(); + onProgressChangedSeekBarParam = onProgressChangedMethod.param(holder.classes().SEEKBAR, "seekBar"); + onProgressChangedProgressParam = onProgressChangedMethod.param(holder.codeModel().INT, "progress"); + onProgressChangedFromUserParam = onProgressChangedMethod.param(holder.codeModel().BOOLEAN, "fromUser"); + } + + private void createOnStartTrackingTouch() { + JMethod onStartTrackingTouchMethod = listenerClass.method(JMod.PUBLIC, holder.codeModel().VOID, "onStartTrackingTouch"); + onStartTrackingTouchMethod.annotate(Override.class); + onStartTrackingTouchBody = onStartTrackingTouchMethod.body(); + onStartTrackingTouchSeekBarParam = onStartTrackingTouchMethod.param(holder.classes().SEEKBAR, "seekBar"); + } + + private void createOnStopTrackingTouch() { + JMethod onStopTrackingTouchMethod = listenerClass.method(JMod.PUBLIC, holder.codeModel().VOID, "onStopTrackingTouch"); + onStopTrackingTouchMethod.annotate(Override.class); + onStopTrackingTouchBody = onStopTrackingTouchMethod.body(); + onStopTrackingTouchSeekBarParam = onStopTrackingTouchMethod.param(holder.classes().SEEKBAR, "seekBar"); + } + + public JBlock getOnProgressChangedBody() { + return onProgressChangedBody; + } + + public JVar getOnProgressChangedSeekBarParam() { + return onProgressChangedSeekBarParam; + } + + public JVar getOnProgressChangedProgressParam() { + return onProgressChangedProgressParam; + } + + public JVar getOnProgressChangedFromUserParam() { + return onProgressChangedFromUserParam; + } + + public JBlock getOnStartTrackingTouchBody() { + return onStartTrackingTouchBody; + } + + public JVar getOnStartTrackingTouchSeekBarParam() { + return onStartTrackingTouchSeekBarParam; + } + + public JBlock getOnStopTrackingTouchBody() { + return onStopTrackingTouchBody; + } + + public JVar getOnStopTrackingTouchSeekBarParam() { + return onStopTrackingTouchSeekBarParam; + } +} From d5a75249f5d1eccbf7a3bb33ea20e8e85d2cf2cf Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 6 Jun 2013 12:04:15 +0200 Subject: [PATCH 58/86] Implement SeekBarTouch(Start & Stop)Handler --- .../handler/AbstractSeekBarTouchHandler.java | 78 +++++++++++++++++++ .../handler/AnnotationHandlers.java | 2 + .../handler/SeekBarTouchStartHandler.java | 25 ++++++ .../handler/SeekBarTouchStopHandler.java | 25 ++++++ .../helper/ValidatorHelper.java | 18 +++++ 5 files changed, 148 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractSeekBarTouchHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarTouchStartHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarTouchStopHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractSeekBarTouchHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractSeekBarTouchHandler.java new file mode 100644 index 0000000000..9985c4d420 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractSeekBarTouchHandler.java @@ -0,0 +1,78 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.helper.AndroidManifest; +import org.androidannotations.helper.IdAnnotationHelper; +import org.androidannotations.helper.IdValidatorHelper; +import org.androidannotations.holder.EComponentWithViewSupportHolder; +import org.androidannotations.holder.OnSeekBarChangeListenerHolder; +import org.androidannotations.model.AndroidSystemServices; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.rclass.IRClass; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.VariableElement; +import java.util.List; + +public abstract class AbstractSeekBarTouchHandler extends BaseAnnotationHandler { + + private IdAnnotationHelper annotationHelper; + + public AbstractSeekBarTouchHandler(Class targetClass, ProcessingEnvironment processingEnvironment) { + super(targetClass, processingEnvironment); + } + + @Override + public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) { + super.setAndroidEnvironment(rClass, androidSystemServices, androidManifest); + annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); + + validatorHelper.resIdsExist(element, IRClass.Res.ID, IdValidatorHelper.FallbackStrategy.USE_ELEMENT_NAME, valid); + + validatorHelper.isNotPrivate(element, valid); + + validatorHelper.doesntThrowException(element, valid); + + validatorHelper.returnTypeIsVoid((ExecutableElement) element, valid); + + validatorHelper.hasSeekBarTouchTrackingMethodParameters((ExecutableElement) element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EComponentWithViewSupportHolder holder) throws Exception { + String methodName = element.getSimpleName().toString(); + + List idsRefs = annotationHelper.extractAnnotationFieldRefs(holder, element, IRClass.Res.ID, true); + + for (JFieldRef idRef : idsRefs) { + OnSeekBarChangeListenerHolder onSeekBarChangeListenerHolder = holder.getOnSeekBarChangeListenerHolder(idRef); + JBlock methodBody = getMethodBodyToCall(onSeekBarChangeListenerHolder); + + JExpression activityRef = holder.getGeneratedClass().staticRef("this"); + JInvocation textChangeCall = methodBody.invoke(activityRef, methodName); + + ExecutableElement executableElement = (ExecutableElement) element; + List parameters = executableElement.getParameters(); + + if (parameters.size() == 1) { + JVar progressParameter = getMethodParamToPass(onSeekBarChangeListenerHolder); + textChangeCall.arg(progressParameter); + } + } + } + + protected abstract JBlock getMethodBodyToCall(OnSeekBarChangeListenerHolder onSeekBarChangeListenerHolder); + protected abstract JVar getMethodParamToPass(OnSeekBarChangeListenerHolder onSeekBarChangeListenerHolder); +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 84ae779074..ee5d01a651 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -75,6 +75,8 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new TextChangeHandler(processingEnvironment)); add(new AfterTextChangeHandler(processingEnvironment)); add(new SeekBarProgressChangeHandler(processingEnvironment)); + add(new SeekBarTouchStartHandler(processingEnvironment)); + add(new SeekBarTouchStopHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarTouchStartHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarTouchStartHandler.java new file mode 100644 index 0000000000..c9d9113730 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarTouchStartHandler.java @@ -0,0 +1,25 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JVar; +import org.androidannotations.annotations.SeekBarTouchStart; +import org.androidannotations.holder.OnSeekBarChangeListenerHolder; + +import javax.annotation.processing.ProcessingEnvironment; + +public class SeekBarTouchStartHandler extends AbstractSeekBarTouchHandler { + + public SeekBarTouchStartHandler(ProcessingEnvironment processingEnvironment) { + super(SeekBarTouchStart.class, processingEnvironment); + } + + @Override + protected JBlock getMethodBodyToCall(OnSeekBarChangeListenerHolder onSeekBarChangeListenerHolder) { + return onSeekBarChangeListenerHolder.getOnStartTrackingTouchBody(); + } + + @Override + protected JVar getMethodParamToPass(OnSeekBarChangeListenerHolder onSeekBarChangeListenerHolder) { + return onSeekBarChangeListenerHolder.getOnStartTrackingTouchSeekBarParam(); + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarTouchStopHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarTouchStopHandler.java new file mode 100644 index 0000000000..3cd4cbc754 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarTouchStopHandler.java @@ -0,0 +1,25 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JVar; +import org.androidannotations.annotations.SeekBarTouchStop; +import org.androidannotations.holder.OnSeekBarChangeListenerHolder; + +import javax.annotation.processing.ProcessingEnvironment; + +public class SeekBarTouchStopHandler extends AbstractSeekBarTouchHandler { + + public SeekBarTouchStopHandler(ProcessingEnvironment processingEnvironment) { + super(SeekBarTouchStop.class, processingEnvironment); + } + + @Override + protected JBlock getMethodBodyToCall(OnSeekBarChangeListenerHolder onSeekBarChangeListenerHolder) { + return onSeekBarChangeListenerHolder.getOnStopTrackingTouchBody(); + } + + @Override + protected JVar getMethodParamToPass(OnSeekBarChangeListenerHolder onSeekBarChangeListenerHolder) { + return onSeekBarChangeListenerHolder.getOnStopTrackingTouchSeekBarParam(); + } +} 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 1eac2d0026..f4f68815f1 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java @@ -1224,4 +1224,22 @@ public void hasSeekBarProgressChangeMethodParameters(ExecutableElement executabl } } + public void hasSeekBarTouchTrackingMethodParameters(ExecutableElement executableElement, IsValid valid) { + List parameters = executableElement.getParameters(); + + if (parameters.size() > 1) { + annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter declaration. You can only have one parameter of type " + CanonicalNameConstants.SEEKBAR + ". Try declaring " + executableElement.getSimpleName() + "(" + CanonicalNameConstants.SEEKBAR + " seekBar);"); + valid.invalidate(); + return; + } + + if (parameters.size() == 1) { + String parameterType = parameters.get(0).asType().toString(); + if (!parameterType.equals(CanonicalNameConstants.SEEKBAR)) { + annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter declaration. You can only have one parameter of type " + CanonicalNameConstants.SEEKBAR + ". Try declaring " + executableElement.getSimpleName() + "(" + CanonicalNameConstants.SEEKBAR + " seekBar);"); + valid.invalidate(); + } + } + + } } From d9c0250c6a902b047c20c223cf064e903df4a009 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 6 Jun 2013 13:04:24 +0200 Subject: [PATCH 59/86] Implement AfterViewsHandler --- .../handler/AfterViewsHandler.java | 42 +++++++++++++++++++ .../handler/AnnotationHandlers.java | 1 + 2 files changed, 43 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterViewsHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterViewsHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterViewsHandler.java new file mode 100644 index 0000000000..01ac07c82c --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterViewsHandler.java @@ -0,0 +1,42 @@ +package org.androidannotations.handler; + +import org.androidannotations.annotations.AfterViews; +import org.androidannotations.holder.EComponentWithViewSupportHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; + +public class AfterViewsHandler extends BaseAnnotationHandler { + + public AfterViewsHandler(ProcessingEnvironment processingEnvironment) { + super(AfterViews.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); + + ExecutableElement executableElement = (ExecutableElement) element; + + validatorHelper.returnTypeIsVoid(executableElement, valid); + + validatorHelper.isNotPrivate(element, valid); + + validatorHelper.doesntThrowException(executableElement, valid); + + validatorHelper.param.zeroParameter(executableElement, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EComponentWithViewSupportHolder holder) throws Exception { + String methodName = element.getSimpleName().toString(); + holder.getOnViewChangedBody().invoke(methodName); + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index ee5d01a651..39282f5c39 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -77,6 +77,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new SeekBarProgressChangeHandler(processingEnvironment)); add(new SeekBarTouchStartHandler(processingEnvironment)); add(new SeekBarTouchStopHandler(processingEnvironment)); + add(new AfterViewsHandler(processingEnvironment)); add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); From 10969cd83a499f1ec96a7f7188dbd38d5077d14f Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 6 Jun 2013 13:16:14 +0200 Subject: [PATCH 60/86] Implement TraceHandler --- .../handler/AnnotationHandlers.java | 25 +++- .../handler/TraceHandler.java | 138 ++++++++++++++++++ 2 files changed, 161 insertions(+), 2 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TraceHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 39282f5c39..815e071ec9 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -12,6 +12,8 @@ import javax.annotation.processing.ProcessingEnvironment; import java.util.*; +import static org.androidannotations.helper.ModelConstants.TRACE_OPTION; + public class AnnotationHandlers { private List> annotationHandlers = new ArrayList>(); @@ -77,10 +79,19 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new SeekBarProgressChangeHandler(processingEnvironment)); add(new SeekBarTouchStartHandler(processingEnvironment)); add(new SeekBarTouchStopHandler(processingEnvironment)); - add(new AfterViewsHandler(processingEnvironment)); - add(new AfterInjectHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); + + /* + * Any view injection or listener binding should occur before + * AfterViewsProcessor + */ + add(new AfterInjectHandler(processingEnvironment)); + add(new AfterViewsHandler(processingEnvironment)); + + if (traceActivated(processingEnvironment)) { + add(new TraceHandler(processingEnvironment)); + } } private void add(AnnotationHandler annotationHandler) { @@ -117,6 +128,16 @@ public void setValidatedModel(AnnotationElements validatedModel) { } } + private boolean traceActivated(ProcessingEnvironment processingEnvironment) { + Map options = processingEnvironment.getOptions(); + if (options.containsKey(TRACE_OPTION)) { + String trace = options.get(TRACE_OPTION); + return !"false".equals(trace); + } else { + return true; + } + } + public Set getSupportedAnnotationTypes() { if (supportedAnnotationNames == null) { Set annotationNames = new HashSet(); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TraceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TraceHandler.java new file mode 100644 index 0000000000..11f7804858 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TraceHandler.java @@ -0,0 +1,138 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.Trace; +import org.androidannotations.helper.APTCodeModelHelper; +import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.ProcessHolder; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; + +import static org.androidannotations.helper.AndroidConstants.*; + +public class TraceHandler extends BaseAnnotationHandler { + + private final APTCodeModelHelper codeModelHelper = new APTCodeModelHelper(); + + public TraceHandler(ProcessingEnvironment processingEnvironment) { + super(Trace.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); + + validatorHelper.isNotPrivate(element, valid); + + validatorHelper.hasValidLogLevel(element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EComponentHolder holder) throws Exception { + ProcessHolder.Classes classes = holder.classes(); + JCodeModel codeModel = holder.codeModel(); + ExecutableElement executableElement = (ExecutableElement) element; + + String tag = extractTag(executableElement); + int level = executableElement.getAnnotation(Trace.class).level(); + + JMethod method = codeModelHelper.overrideAnnotatedMethod(executableElement, holder); + + JBlock previousMethodBody = codeModelHelper.removeBody(method); + + JBlock methodBody = method.body(); + + JInvocation isLoggableInvocation = classes.LOG.staticInvoke("isLoggable"); + isLoggableInvocation.arg(JExpr.lit(tag)).arg(logLevelFromInt(level, classes.LOG)); + + JConditional ifStatement = methodBody._if(isLoggableInvocation); + + JInvocation currentTimeInvoke = classes.SYSTEM.staticInvoke("currentTimeMillis"); + JBlock _thenBody = ifStatement._then(); + JVar startDeclaration = _thenBody.decl(codeModel.LONG, "start", currentTimeInvoke); + + String methodName = "[" + element.toString() + "]"; + + // Log In + String logMethodName = logMethodNameFromLevel(level); + JInvocation logEnterInvoke = classes.LOG.staticInvoke(logMethodName); + logEnterInvoke.arg(tag); + + JExpression enterMessage = JExpr.lit("Entering " + methodName); + logEnterInvoke.arg(enterMessage); + _thenBody.add(logEnterInvoke); + + JTryBlock tryBlock = _thenBody._try(); + + tryBlock.body().add(previousMethodBody); + + JBlock finallyBlock = tryBlock._finally(); + + JVar durationDeclaration = finallyBlock.decl(codeModel.LONG, "duration", currentTimeInvoke.minus(startDeclaration)); + + JInvocation logExitInvoke = classes.LOG.staticInvoke(logMethodName); + logExitInvoke.arg(tag); + + JExpression exitMessage = JExpr.lit("Exiting " + methodName + ", duration in ms: ").plus(durationDeclaration); + logExitInvoke.arg(exitMessage); + finallyBlock.add(logExitInvoke); + + JBlock elseBlock = ifStatement._else(); + + elseBlock.add(previousMethodBody); + } + + private String logMethodNameFromLevel(int level) { + switch (level) { + case LOG_DEBUG: + return "d"; + case LOG_VERBOSE: + return "v"; + case LOG_INFO: + return "i"; + case LOG_WARN: + return "w"; + case LOG_ERROR: + return "e"; + default: + throw new IllegalArgumentException("Unrecognized Log level : " + level); + } + } + + private JFieldRef logLevelFromInt(int level, JClass logClass) { + switch (level) { + case LOG_DEBUG: + return logClass.staticRef("DEBUG"); + case LOG_VERBOSE: + return logClass.staticRef("VERBOSE"); + case LOG_INFO: + return logClass.staticRef("INFO"); + case LOG_WARN: + return logClass.staticRef("WARN"); + case LOG_ERROR: + return logClass.staticRef("ERROR"); + default: + throw new IllegalArgumentException("Unrecognized log level. Given value:" + level); + } + } + + private String extractTag(Element element) { + Trace annotation = element.getAnnotation(Trace.class); + String tag = annotation.tag(); + if (Trace.DEFAULT_TAG.equals(tag)) { + tag = element.getEnclosingElement().getSimpleName().toString(); + } + if (tag.length() > 23) { + tag = tag.substring(0, 23); + } + return tag; + } +} From f5bb517a59f5787fee3a8f200cee13aa5632516b Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 6 Jun 2013 13:21:06 +0200 Subject: [PATCH 61/86] Implement SubscribeHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/SubscribeHandler.java | 63 +++++++++++++++++++ 2 files changed, 64 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SubscribeHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 815e071ec9..f587ed0392 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -79,6 +79,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new SeekBarProgressChangeHandler(processingEnvironment)); add(new SeekBarTouchStartHandler(processingEnvironment)); add(new SeekBarTouchStopHandler(processingEnvironment)); + add(new SubscribeHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SubscribeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SubscribeHandler.java new file mode 100644 index 0000000000..b31f27f692 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SubscribeHandler.java @@ -0,0 +1,63 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JMethod; +import org.androidannotations.helper.APTCodeModelHelper; +import org.androidannotations.helper.CanonicalNameConstants; +import org.androidannotations.helper.TargetAnnotationHelper; +import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; + +import static org.androidannotations.helper.CanonicalNameConstants.SUBSCRIBE; + +public class SubscribeHandler extends BaseAnnotationHandler { + + private final TargetAnnotationHelper annotationHelper; + private final APTCodeModelHelper codeModelHelper = new APTCodeModelHelper(); + + public SubscribeHandler(ProcessingEnvironment processingEnvironment) { + super(CanonicalNameConstants.SUBSCRIBE, processingEnvironment); + annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + if (!annotationHelper.enclosingElementHasEnhancedComponentAnnotation(element)) { + return false; + } + + IsValid valid = new IsValid(); + + ExecutableElement executableElement = (ExecutableElement) element; + + /* + * We check that twice to skip invalid annotated elements + */ + validatorHelper.enclosingElementHasEnhancedComponentAnnotation(executableElement, validatedElements, valid); + + validatorHelper.returnTypeIsVoid(executableElement, valid); + + validatorHelper.isPublic(element, valid); + + validatorHelper.doesntThrowException(executableElement, valid); + + validatorHelper.isNotFinal(element, valid); + + validatorHelper.param.hasExactlyOneParameter(executableElement, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EComponentHolder holder) throws Exception { + ExecutableElement executableElement = (ExecutableElement) element; + + JMethod delegatingMethod = codeModelHelper.overrideAnnotatedMethod(executableElement, holder); + + delegatingMethod.annotate(holder.refClass(SUBSCRIBE)); + } +} From 219f72b605e7007c2f5667e3275059fc58e9a386 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 6 Jun 2013 13:24:14 +0200 Subject: [PATCH 62/86] Implement ProduceHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/ProduceHandler.java | 63 +++++++++++++++++++ 2 files changed, 64 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ProduceHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index f587ed0392..557ad6ff0e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -80,6 +80,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new SeekBarTouchStartHandler(processingEnvironment)); add(new SeekBarTouchStopHandler(processingEnvironment)); add(new SubscribeHandler(processingEnvironment)); + add(new ProduceHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ProduceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ProduceHandler.java new file mode 100644 index 0000000000..a9246c24ec --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ProduceHandler.java @@ -0,0 +1,63 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JMethod; +import org.androidannotations.helper.APTCodeModelHelper; +import org.androidannotations.helper.CanonicalNameConstants; +import org.androidannotations.helper.TargetAnnotationHelper; +import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; + +import static org.androidannotations.helper.CanonicalNameConstants.PRODUCE; + +public class ProduceHandler extends BaseAnnotationHandler { + + private final TargetAnnotationHelper annotationHelper; + private final APTCodeModelHelper codeModelHelper = new APTCodeModelHelper(); + + public ProduceHandler(ProcessingEnvironment processingEnvironment) { + super(CanonicalNameConstants.PRODUCE, processingEnvironment); + annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + if (!annotationHelper.enclosingElementHasEnhancedComponentAnnotation(element)) { + return false; + } + + IsValid valid = new IsValid(); + + ExecutableElement executableElement = (ExecutableElement) element; + + /* + * We check that twice to skip invalid annotated elements + */ + validatorHelper.enclosingElementHasEnhancedComponentAnnotation(executableElement, validatedElements, valid); + + validatorHelper.returnTypeIsNotVoid(executableElement, valid); + + validatorHelper.isPublic(element, valid); + + validatorHelper.doesntThrowException(executableElement, valid); + + validatorHelper.isNotFinal(element, valid); + + validatorHelper.param.zeroParameter(executableElement, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EComponentHolder holder) throws Exception { + ExecutableElement executableElement = (ExecutableElement) element; + + JMethod delegatingMethod = codeModelHelper.overrideAnnotatedMethod(executableElement, holder); + + delegatingMethod.annotate(holder.refClass(PRODUCE)); + } +} From 5853e5a9716de29ea69a97c6fa50f76186ebfd51 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 6 Jun 2013 13:32:17 +0200 Subject: [PATCH 63/86] Implement UiThreadHandler --- .../handler/AbstractRunnableHandler.java | 37 ++++++++++++++++++ .../handler/AnnotationHandlers.java | 1 + .../handler/UiThreadHandler.java | 38 +++++++++++++++++++ .../helper/APTCodeModelHelper.java | 32 ++++++++++++++++ .../holder/EComponentHolder.java | 13 +++++++ 5 files changed, 121 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractRunnableHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/UiThreadHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractRunnableHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractRunnableHandler.java new file mode 100644 index 0000000000..9ce960a595 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractRunnableHandler.java @@ -0,0 +1,37 @@ +package org.androidannotations.handler; + +import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; + +public abstract class AbstractRunnableHandler extends BaseAnnotationHandler { + + public AbstractRunnableHandler(Class targetClass, ProcessingEnvironment processingEnvironment) { + super(targetClass, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); + + ExecutableElement executableElement = (ExecutableElement) element; + + validatorHelper.returnTypeIsVoid(executableElement, valid); + + validatorHelper.isNotPrivate(element, valid); + + validatorHelper.doesntThrowException(executableElement, valid); + + validatorHelper.isNotFinal(element, valid); + + validatorHelper.isNotSynchronized(element, valid); + + return valid.isValid(); + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 557ad6ff0e..c505c87cb3 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -81,6 +81,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new SeekBarTouchStopHandler(processingEnvironment)); add(new SubscribeHandler(processingEnvironment)); add(new ProduceHandler(processingEnvironment)); + add(new UiThreadHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/UiThreadHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/UiThreadHandler.java new file mode 100644 index 0000000000..a27a085e21 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/UiThreadHandler.java @@ -0,0 +1,38 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.UiThread; +import org.androidannotations.helper.APTCodeModelHelper; +import org.androidannotations.holder.EComponentHolder; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; + +import static com.sun.codemodel.JExpr._new; +import static com.sun.codemodel.JExpr.lit; + +public class UiThreadHandler extends AbstractRunnableHandler { + + private final APTCodeModelHelper codeModelHelper = new APTCodeModelHelper(); + + public UiThreadHandler(ProcessingEnvironment processingEnvironment) { + super(UiThread.class, processingEnvironment); + } + + @Override + public void process(Element element, EComponentHolder holder) throws Exception { + ExecutableElement executableElement = (ExecutableElement) element; + JMethod delegatingMethod = codeModelHelper.overrideAnnotatedMethod(executableElement, holder); + JDefinedClass anonymousRunnableClass = codeModelHelper.createDelegatingAnonymousRunnableClass(holder, delegatingMethod); + + UiThread annotation = element.getAnnotation(UiThread.class); + long delay = annotation.delay(); + + if (delay == 0) { + delegatingMethod.body().invoke(holder.getHandler(), "post").arg(_new(anonymousRunnableClass)); + } else { + delegatingMethod.body().invoke(holder.getHandler(), "postDelayed").arg(_new(anonymousRunnableClass)).arg(lit(delay)); + } + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java index 399fdae359..f37b2a335b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java @@ -18,6 +18,7 @@ import com.sun.codemodel.*; import org.androidannotations.holder.EComponentHolder; import org.androidannotations.holder.GeneratedClassHolder; +import org.androidannotations.process.ProcessHolder; import org.androidannotations.processing.EBeanHolder; import org.androidannotations.processing.EBeansHolder.Classes; @@ -301,6 +302,37 @@ public String getIdStringFromIdFieldRef(JFieldRef idRef) { throw new IllegalStateException("Unable to extract target name from JFieldRef"); } + public JDefinedClass createDelegatingAnonymousRunnableClass(EComponentHolder holder, JMethod delegatedMethod) { + + JCodeModel codeModel = holder.codeModel(); + ProcessHolder.Classes classes = holder.classes(); + + JDefinedClass anonymousRunnableClass; + JBlock previousMethodBody = removeBody(delegatedMethod); + + anonymousRunnableClass = codeModel.anonymousClass(Runnable.class); + + JMethod runMethod = anonymousRunnableClass.method(JMod.PUBLIC, codeModel.VOID, "run"); + runMethod.annotate(Override.class); + + JBlock runMethodBody = runMethod.body(); + JTryBlock runTry = runMethodBody._try(); + + runTry.body().add(previousMethodBody); + + JCatchBlock runCatch = runTry._catch(classes.RUNTIME_EXCEPTION); + JVar exceptionParam = runCatch.param("e"); + + JInvocation errorInvoke = classes.LOG.staticInvoke("e"); + + errorInvoke.arg(holder.getGeneratedClass().name()); + errorInvoke.arg("A runtime exception was thrown while executing code in a runnable"); + errorInvoke.arg(exceptionParam); + + runCatch.body().add(errorInvoke); + return anonymousRunnableClass; + } + public JDefinedClass createDelegatingAnonymousRunnableClass(EBeanHolder holder, JMethod delegatedMethod) { JCodeModel codeModel = holder.codeModel(); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java index e1ee3e4018..82d468f27f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java @@ -18,6 +18,7 @@ public abstract class EComponentHolder extends BaseGeneratedClassHolder { protected JMethod init; private JVar resourcesRef; private Map databaseHelperRefs = new HashMap(); + private JVar handler; public EComponentHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); @@ -72,4 +73,16 @@ private JFieldVar setDatabaseHelperRef(TypeMirror databaseHelperTypeMirror) { return databaseHelperRef; } + + public JVar getHandler() { + if (handler == null) { + setHandler(); + } + return handler; + } + + private void setHandler() { + JClass handlerClass = classes().HANDLER; + handler = generatedClass.field(JMod.PRIVATE, handlerClass, "handler_", JExpr._new(handlerClass)); + } } From 5218a5e90b7c54bbf77580b5baab6bdd405667d0 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 6 Jun 2013 13:35:17 +0200 Subject: [PATCH 64/86] Implement BackgroundHandler --- .../handler/AnnotationHandlers.java | 2 +- .../handler/BackgroundHandler.java | 50 +++++++++++++++++++ 2 files changed, 51 insertions(+), 1 deletion(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BackgroundHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index c505c87cb3..9fd1283864 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -82,7 +82,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new SubscribeHandler(processingEnvironment)); add(new ProduceHandler(processingEnvironment)); add(new UiThreadHandler(processingEnvironment)); - + add(new BackgroundHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); /* diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BackgroundHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BackgroundHandler.java new file mode 100644 index 0000000000..a70b970117 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BackgroundHandler.java @@ -0,0 +1,50 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JClass; +import com.sun.codemodel.JDefinedClass; +import com.sun.codemodel.JInvocation; +import com.sun.codemodel.JMethod; +import org.androidannotations.annotations.Background; +import org.androidannotations.api.BackgroundExecutor; +import org.androidannotations.helper.APTCodeModelHelper; +import org.androidannotations.holder.EComponentHolder; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; + +import static com.sun.codemodel.JExpr._new; +import static com.sun.codemodel.JExpr.lit; + +public class BackgroundHandler extends AbstractRunnableHandler { + + private final APTCodeModelHelper codeModelHelper = new APTCodeModelHelper(); + + public BackgroundHandler(ProcessingEnvironment processingEnvironment) { + super(Background.class, processingEnvironment); + } + + @Override + public void process(Element element, EComponentHolder holder) throws Exception { + ExecutableElement executableElement = (ExecutableElement) element; + + holder.generateApiClass(element, BackgroundExecutor.class); + + JMethod delegatingMethod = codeModelHelper.overrideAnnotatedMethod(executableElement, holder); + JDefinedClass anonymousRunnableClass = codeModelHelper.createDelegatingAnonymousRunnableClass(holder, delegatingMethod); + + Background annotation = element.getAnnotation(Background.class); + long delay = annotation.delay(); + + JClass backgroundExecutorClass = holder.refClass(BackgroundExecutor.class); + JInvocation executeCall; + + if (delay == 0) { + executeCall = backgroundExecutorClass.staticInvoke("execute").arg(_new(anonymousRunnableClass)); + } else { + executeCall = backgroundExecutorClass.staticInvoke("executeDelayed").arg(_new(anonymousRunnableClass)).arg(lit(delay)); + } + + delegatingMethod.body().add(executeCall); + } +} From 95b7568871bdee1fda114ad9b4c13507b8d2b8fb Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 6 Jun 2013 13:47:35 +0200 Subject: [PATCH 65/86] Implement HttpsClientHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/HttpsClientHandler.java | 157 ++++++++++++++++++ .../rclass/CoumpoundInnerClass.java | 19 +++ .../rclass/IRInnerClass.java | 7 +- .../rclass/RInnerClass.java | 12 ++ 5 files changed, 195 insertions(+), 1 deletion(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 9fd1283864..d0f9e2cf85 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -84,6 +84,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new UiThreadHandler(processingEnvironment)); add(new BackgroundHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); + add(new HttpsClientHandler(processingEnvironment)); /* * Any view injection or listener binding should occur before diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java new file mode 100644 index 0000000000..f790b66df9 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java @@ -0,0 +1,157 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.*; +import org.androidannotations.annotations.HttpsClient; +import org.androidannotations.annotations.ResId; +import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.ProcessHolder; +import org.androidannotations.rclass.IRClass; +import org.androidannotations.rclass.IRInnerClass; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + +import static com.sun.codemodel.JExpr.*; + +public class HttpsClientHandler extends BaseAnnotationHandler { + + public HttpsClientHandler(ProcessingEnvironment processingEnvironment) { + super(HttpsClient.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); + + validatorHelper.annotationParameterIsOptionalValidResId(element, IRClass.Res.RAW, "keyStore", valid); + validatorHelper.annotationParameterIsOptionalValidResId(element, IRClass.Res.RAW, "trustStore", valid); + + validatorHelper.isNotPrivate(element, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EComponentHolder holder) throws Exception { + HttpsClient annotation = element.getAnnotation(HttpsClient.class); + int trustStoreRawId = annotation.trustStore(); + String trustStorePwd = annotation.trustStorePwd(); + int keyStoreRawId = annotation.keyStore(); + String keyStorePwd = annotation.keyStorePwd(); + + boolean allowAllHostnames = annotation.allowAllHostnames(); + boolean useCustomTrustStore = ResId.DEFAULT_VALUE != trustStoreRawId; + boolean useCustomKeyStore = ResId.DEFAULT_VALUE != keyStoreRawId; + + String fieldName = element.getSimpleName().toString(); + JBlock methodBody = holder.getInit().body(); + + ProcessHolder.Classes classes = holder.classes(); + + JDefinedClass jAnonClass = holder.codeModel().anonymousClass(classes.DEFAULT_HTTP_CLIENT); + + JMethod method = jAnonClass.method(JMod.PROTECTED, classes.CLIENT_CONNECTION_MANAGER, "createClientConnectionManager"); + method.annotate(Override.class); + + JTryBlock jTryBlock = method.body()._try(); + JVar jVarTrusted = null; + JVar jVarKeystore = null; + + if (useCustomKeyStore) { + jVarKeystore = jTryBlock.body().decl(classes.KEY_STORE, "keystore"); + jVarKeystore.init(classes.KEY_STORE.staticInvoke("getInstance").arg("BKS")); + } + + if (useCustomTrustStore || useCustomKeyStore) { + /* + * use default trust store + */ + jVarTrusted = jTryBlock.body().decl(classes.KEY_STORE, "trusted"); + jVarTrusted.init(classes.KEY_STORE.staticInvoke("getInstance").arg("BKS")); + + } + + JVar jVarRes = null; + JVar jVarTrstFile = null; + JVar jVarKeyFile = null; + + if (useCustomKeyStore || useCustomTrustStore) { + jVarRes = jTryBlock.body().decl(classes.RESOURCES, "res", invoke("getResources")); + } + + IRInnerClass rInnerClass = rClass.get(IRClass.Res.RAW); + if (useCustomKeyStore) { + JFieldRef rawIdRef = rInnerClass.getIdStaticRef(keyStoreRawId, holder); + JInvocation jInvRawKey = jVarRes.invoke("openRawResource").arg(rawIdRef); + jVarKeyFile = jTryBlock.body().decl(classes.INPUT_STREAM, "inKeystore", jInvRawKey); + } + + if (useCustomTrustStore) { + JFieldRef rawIdRef = rInnerClass.getIdStaticRef(trustStoreRawId, holder); + JInvocation jInvRawTrust = jVarRes.invoke("openRawResource").arg(rawIdRef); + jVarTrstFile = jTryBlock.body().decl(classes.INPUT_STREAM, "inTrustStore", jInvRawTrust); + + } else if (useCustomKeyStore) { + jVarTrstFile = jTryBlock.body().decl(classes.INPUT_STREAM, "inTrustStore", _new(classes.FILE_INPUT_STREAM).arg("/system/etc/security/cacerts.bks")); + } + + // try load + if (useCustomKeyStore || useCustomTrustStore) { + JTryBlock jTryLoad = jTryBlock.body()._try(); + + if (useCustomKeyStore) { + jTryLoad.body().add(invoke(jVarKeystore, "load").arg(jVarKeyFile).arg(invoke(lit(keyStorePwd), "toCharArray"))); + } + + jTryLoad.body().add(invoke(jVarTrusted, "load").arg(jVarTrstFile).arg(invoke(lit(trustStorePwd), "toCharArray"))); + + // finally load + JBlock jFinally = jTryLoad._finally(); + if (useCustomKeyStore) { + jFinally.add(invoke(jVarKeyFile, "close")); + } + + jFinally.add(invoke(jVarTrstFile, "close")); + } + + if (null == jVarKeystore && null == jVarTrusted) { + JVar jVarCcm = jTryBlock.body().decl(classes.CLIENT_CONNECTION_MANAGER, "ccm"); + jVarCcm.init(_super().invoke("createClientConnectionManager")); + + if (allowAllHostnames) { + JExpression jCast = cast(classes.SSL_SOCKET_FACTORY, jVarCcm.invoke("getSchemeRegistry").invoke("getScheme").arg("https").invoke("getSocketFactory")); + jTryBlock.body().add(jCast.invoke("setHostnameVerifier").arg(classes.SSL_SOCKET_FACTORY.staticRef("ALLOW_ALL_HOSTNAME_VERIFIER"))); + } + + jTryBlock.body()._return(jVarCcm); + + } else { + JVar jVarSslFact = jTryBlock.body().decl(classes.SSL_SOCKET_FACTORY, "newSslSocketFactory"); + jVarSslFact.init(_new(classes.SSL_SOCKET_FACTORY).arg(null == jVarKeystore ? _null() : jVarKeystore).arg(keyStorePwd).arg(jVarTrusted)); + + if (allowAllHostnames) { + jTryBlock.body().add(invoke(jVarSslFact, "setHostnameVerifier").arg(classes.SSL_SOCKET_FACTORY.staticRef("ALLOW_ALL_HOSTNAME_VERIFIER"))); + } + + JVar jVarSchemeReg = jTryBlock.body().decl(classes.SCHEME_REGISTRY, "registry"); + jVarSchemeReg.init(_new(classes.SCHEME_REGISTRY)); + jTryBlock.body().add(invoke(jVarSchemeReg, "register").arg(_new(classes.SCHEME).arg("https").arg(jVarSslFact).arg(lit(443)))); + + JVar jVarCcm = jTryBlock.body().decl(classes.CLIENT_CONNECTION_MANAGER, "ccm"); + jVarCcm.init(_new(classes.SINGLE_CLIENT_CONN_MANAGER).arg(invoke("getParams")).arg(jVarSchemeReg)); + jTryBlock.body()._return(jVarCcm); + } + + // catch block + JCatchBlock jCatchBlock = jTryBlock._catch(classes.EXCEPTION); + JVar jVarExceptionParam = jCatchBlock.param("e"); + jCatchBlock.body().add(jVarExceptionParam.invoke("printStackTrace")); + jCatchBlock.body()._return(_super().invoke("createClientConnectionManager")); + + methodBody.assign(ref(fieldName), _new(jAnonClass)); + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/CoumpoundInnerClass.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/CoumpoundInnerClass.java index eda77a7d98..721793c842 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/CoumpoundInnerClass.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/CoumpoundInnerClass.java @@ -15,6 +15,7 @@ */ package org.androidannotations.rclass; +import org.androidannotations.holder.GeneratedClassHolder; import org.androidannotations.processing.EBeanHolder; import com.sun.codemodel.JFieldRef; @@ -56,6 +57,15 @@ public String getIdQualifiedName(String name) { return idQualifiedName; } + @Override + public JFieldRef getIdStaticRef(Integer idValue, GeneratedClassHolder holder) { + JFieldRef idStaticRef = rInnerClass.getIdStaticRef(idValue, holder); + if (idStaticRef == null) { + idStaticRef = androidRInnerClass.getIdStaticRef(idValue, holder); + } + return idStaticRef; + } + @Override public JFieldRef getIdStaticRef(Integer idValue, EBeanHolder holder) { JFieldRef idStaticRef = rInnerClass.getIdStaticRef(idValue, holder); @@ -65,6 +75,15 @@ public JFieldRef getIdStaticRef(Integer idValue, EBeanHolder holder) { return idStaticRef; } + @Override + public JFieldRef getIdStaticRef(String name, GeneratedClassHolder holder) { + JFieldRef idStaticRef = rInnerClass.getIdStaticRef(name, holder); + if (idStaticRef == null) { + idStaticRef = androidRInnerClass.getIdStaticRef(name, holder); + } + return idStaticRef; + } + @Override public JFieldRef getIdStaticRef(String name, EBeanHolder holder) { JFieldRef idStaticRef = rInnerClass.getIdStaticRef(name, holder); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/IRInnerClass.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/IRInnerClass.java index ebe1656519..5652ed6279 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/IRInnerClass.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/IRInnerClass.java @@ -15,8 +15,9 @@ */ package org.androidannotations.rclass; -import org.androidannotations.processing.EBeanHolder; import com.sun.codemodel.JFieldRef; +import org.androidannotations.holder.GeneratedClassHolder; +import org.androidannotations.processing.EBeanHolder; public interface IRInnerClass { @@ -28,8 +29,12 @@ public interface IRInnerClass { String getIdQualifiedName(String name); + JFieldRef getIdStaticRef(Integer idValue, GeneratedClassHolder holder); + JFieldRef getIdStaticRef(Integer idValue, EBeanHolder holder); + JFieldRef getIdStaticRef(String name, GeneratedClassHolder holder); + JFieldRef getIdStaticRef(String name, EBeanHolder holder); final IRInnerClass EMPTY_R_INNER_CLASS = new RInnerClass(null); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/RInnerClass.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/RInnerClass.java index 105ff0af70..2f0f2d674d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/RInnerClass.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/RInnerClass.java @@ -99,12 +99,24 @@ public String getIdQualifiedName(String name) { } } + @Override + public JFieldRef getIdStaticRef(Integer idValue, GeneratedClassHolder holder) { + String layoutFieldQualifiedName = getIdQualifiedName(idValue); + return extractIdStaticRef(holder, layoutFieldQualifiedName); + } + @Override public JFieldRef getIdStaticRef(Integer idValue, EBeanHolder holder) { String layoutFieldQualifiedName = getIdQualifiedName(idValue); return extractIdStaticRef(holder, layoutFieldQualifiedName); } + @Override + public JFieldRef getIdStaticRef(String name, GeneratedClassHolder holder) { + String layoutFieldQualifiedName = getIdQualifiedName(name); + return extractIdStaticRef(holder, layoutFieldQualifiedName); + } + @Override public JFieldRef getIdStaticRef(String name, EBeanHolder holder) { String layoutFieldQualifiedName = getIdQualifiedName(name); From cea95c2739e56a636106122391f180ccc5beadb9 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 6 Jun 2013 14:34:15 +0200 Subject: [PATCH 66/86] Implement OnActivityResultHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/OnActivityResultHandler.java | 86 ++++++++++++++++ .../helper/ValidatorHelper.java | 28 ++++++ .../holder/EActivityHolder.java | 41 +++++--- .../holder/EFragmentHolder.java | 19 +++- .../holder/HasOnActivityResult.java | 10 ++ .../holder/OnActivityResultHolder.java | 97 +++++++++++++++++++ .../holder/RoboGuiceHolder.java | 24 +---- 8 files changed, 270 insertions(+), 36 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OnActivityResultHandler.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOnActivityResult.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/OnActivityResultHolder.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index d0f9e2cf85..736b6fca3d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -85,6 +85,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new BackgroundHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); add(new HttpsClientHandler(processingEnvironment)); + add(new OnActivityResultHandler(processingEnvironment)); /* * Any view injection or listener binding should occur before diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OnActivityResultHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OnActivityResultHandler.java new file mode 100644 index 0000000000..ee443f1110 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OnActivityResultHandler.java @@ -0,0 +1,86 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JInvocation; +import com.sun.codemodel.JVar; +import org.androidannotations.annotations.OnActivityResult; +import org.androidannotations.helper.CanonicalNameConstants; +import org.androidannotations.holder.HasOnActivityResult; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +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 java.util.List; + +public class OnActivityResultHandler extends BaseAnnotationHandler { + + public OnActivityResultHandler(ProcessingEnvironment processingEnvironment) { + super(OnActivityResult.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.enclosingElementHasEActivityOrEFragment(element, validatedElements, valid); + + validatorHelper.isNotPrivate(element, valid); + + validatorHelper.doesntThrowException(element, valid); + + OnActivityResult onResultAnnotation = element.getAnnotation(OnActivityResult.class); + validatorHelper.annotationValuePositiveAndInAShort(element, valid, onResultAnnotation.value()); + + ExecutableElement executableElement = (ExecutableElement) element; + validatorHelper.returnTypeIsVoid(executableElement, valid); + + validatorHelper.hasOnResultMethodParameters(executableElement, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, HasOnActivityResult holder) throws Exception { + String methodName = element.getSimpleName().toString(); + + ExecutableElement executableElement = (ExecutableElement) element; + List parameters = executableElement.getParameters(); + + int intentParameterPosition = -1; + int resultCodeParameterPosition = -1; + + for (int i = 0; i < parameters.size(); i++) { + VariableElement parameter = parameters.get(i); + TypeMirror parameterType = parameter.asType(); + + if (CanonicalNameConstants.INTENT.equals(parameterType.toString())) { + intentParameterPosition = i; + } else if (parameterType.getKind().equals(TypeKind.INT) // + || CanonicalNameConstants.INTEGER.equals(parameterType.toString())) { + resultCodeParameterPosition = i; + } + } + + int requestCode = executableElement.getAnnotation(OnActivityResult.class).value(); + JBlock onActivityResultCase = holder.getOnActivityResultCaseBlock(requestCode); + + JExpression activityRef = holder.getGeneratedClass().staticRef("this"); + JInvocation onResultInvocation = onActivityResultCase.invoke(activityRef, methodName); + + for (int i = 0; i < parameters.size(); i++) { + if (i == intentParameterPosition) { + JVar intentParameter = holder.getOnActivityResultDataParam(); + onResultInvocation.arg(intentParameter); + } else if (i == resultCodeParameterPosition) { + JVar resultCodeParameter = holder.getOnActivityResultResultCodeParam(); + onResultInvocation.arg(resultCodeParameter); + } + } + } +} 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 f4f68815f1..259914374f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java @@ -1242,4 +1242,32 @@ public void hasSeekBarTouchTrackingMethodParameters(ExecutableElement executable } } + + public void hasOnResultMethodParameters(ExecutableElement executableElement, IsValid valid) { + List parameters = executableElement.getParameters(); + boolean resultCodeParameterFound = false; + boolean intentParameterFound = false; + for (VariableElement parameter : parameters) { + TypeMirror parameterType = parameter.asType(); + if (parameterType.toString().equals(CanonicalNameConstants.INTEGER) // + || parameterType.getKind().equals(TypeKind.INT)) { + if (resultCodeParameterFound) { + annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter declaration. you can declare only one parameter of type int or java.lang.Integer"); + valid.invalidate(); + } + resultCodeParameterFound = true; + continue; + } + if (parameterType.toString().equals(CanonicalNameConstants.INTENT)) { + if (intentParameterFound) { + annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter declaration. you can declare only one parameter of type android.content.Intent"); + valid.invalidate(); + } + intentParameterFound = true; + continue; + } + valid.invalidate(); + annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter type. %s can only have a android.content.Intent parameter and/or an Integer parameter"); + } + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java index 8a2c3164b6..705d88ab66 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java @@ -18,7 +18,7 @@ import static com.sun.codemodel.JMod.PRIVATE; import static com.sun.codemodel.JMod.PUBLIC; -public class EActivityHolder extends EComponentWithViewSupportHolder implements HasIntentBuilder, HasExtras, HasInstanceState, HasOptionsMenu { +public class EActivityHolder extends EComponentWithViewSupportHolder implements HasIntentBuilder, HasExtras, HasInstanceState, HasOptionsMenu, HasOnActivityResult { private GreenDroidHelper greenDroidHelper; private JMethod onCreate; @@ -28,6 +28,7 @@ public class EActivityHolder extends EComponentWithViewSupportHolder implements private JDefinedClass intentBuilderClass; private JFieldVar intentField; private InstanceStateHolder instanceStateHolder; + private OnActivityResultHolder onActivityResultHolder; private RoboGuiceHolder roboGuiceHolder; private JMethod injectExtrasMethod; private JBlock injectExtrasBlock; @@ -48,6 +49,7 @@ public class EActivityHolder extends EComponentWithViewSupportHolder implements public EActivityHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); instanceStateHolder = new InstanceStateHolder(this); + onActivityResultHolder = new OnActivityResultHolder(this); createIntentBuilder(); handleBackPressed(); } @@ -179,20 +181,6 @@ protected void setOnContentChanged() { roboGuiceHolder.onContentChangedAfterSuperBlock = body.block(); } - protected void setOnActivityResult() { - JMethod method = generatedClass.method(JMod.PUBLIC, codeModel().VOID, "onActivityResult"); - method.annotate(Override.class); - JVar requestCode = method.param(codeModel().INT, "requestCode"); - JVar resultCode = method.param(codeModel().INT, "resultCode"); - JVar data = method.param(classes().INTENT, "data"); - JBlock body = method.body(); - body.invoke(_super(), method).arg(requestCode).arg(resultCode).arg(data); - roboGuiceHolder.onActivityResultAfterSuperBlock = body.block(); - roboGuiceHolder.requestCode = requestCode; - roboGuiceHolder.resultCode = requestCode; - roboGuiceHolder.data = data; - } - private void setOnCreateOptionsMenu() { JClass menuClass = classes().MENU; JClass menuInflaterClass = classes().MENU_INFLATER; @@ -626,4 +614,27 @@ private void setOnRetainNonConfigurationInstance() throws JClassAlreadyExistsExc onRetainNonConfigurationInstanceBindBlock = methodBody.block(); methodBody._return(onRetainNonConfigurationInstance); } + + @Override + public JBlock getOnActivityResultCaseBlock(int requestCode) { + return onActivityResultHolder.getCaseBlock(requestCode); + } + + @Override + public JVar getOnActivityResultDataParam() { + return onActivityResultHolder.getDataParam(); + } + + @Override + public JVar getOnActivityResultResultCodeParam() { + return onActivityResultHolder.getResultCodeParam(); + } + + public JBlock getOnActivityResultAfterSuperBlock() { + return onActivityResultHolder.getAfterSuperBlock(); + } + + public JVar getOnActivityResultRequestCodeParam() { + return onActivityResultHolder.getRequestCodeParam(); + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java index 80ff60e2f0..86945a7c3b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java @@ -11,7 +11,7 @@ import static com.sun.codemodel.JExpr.*; import static com.sun.codemodel.JMod.*; -public class EFragmentHolder extends EComponentWithViewSupportHolder implements HasInstanceState, HasOptionsMenu { +public class EFragmentHolder extends EComponentWithViewSupportHolder implements HasInstanceState, HasOptionsMenu, HasOnActivityResult { private JFieldVar contentView; private JBlock setContentViewBlock; @@ -23,6 +23,7 @@ public class EFragmentHolder extends EComponentWithViewSupportHolder implements private JBlock injectArgsBlock; private JVar injectBundleArgs; private InstanceStateHolder instanceStateHolder; + private OnActivityResultHolder onActivityResultHolder; private JBlock onCreateOptionsMenuMethodBody; private JVar onCreateOptionsMenuMenuInflaterVar; private JVar onCreateOptionsMenuMenuParam; @@ -33,6 +34,7 @@ public class EFragmentHolder extends EComponentWithViewSupportHolder implements public EFragmentHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); instanceStateHolder = new InstanceStateHolder(this); + onActivityResultHolder = new OnActivityResultHolder(this); createOnCreate(); createOnViewCreated(); createFragmentBuilder(); @@ -317,4 +319,19 @@ public JBlock getOnOptionsItemSelectedIfElseBlock() { } return onOptionsItemSelectedIfElseBlock; } + + @Override + public JBlock getOnActivityResultCaseBlock(int requestCode) { + return onActivityResultHolder.getCaseBlock(requestCode); + } + + @Override + public JVar getOnActivityResultDataParam() { + return onActivityResultHolder.getDataParam(); + } + + @Override + public JVar getOnActivityResultResultCodeParam() { + return onActivityResultHolder.getResultCodeParam(); + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOnActivityResult.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOnActivityResult.java new file mode 100644 index 0000000000..7f75d26baf --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOnActivityResult.java @@ -0,0 +1,10 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JVar; + +public interface HasOnActivityResult extends GeneratedClassHolder { + JBlock getOnActivityResultCaseBlock(int requestCode); + JVar getOnActivityResultDataParam(); + JVar getOnActivityResultResultCodeParam(); +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/OnActivityResultHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/OnActivityResultHolder.java new file mode 100644 index 0000000000..d52f7cb822 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/OnActivityResultHolder.java @@ -0,0 +1,97 @@ +package org.androidannotations.holder; + +import com.sun.codemodel.*; +import org.androidannotations.process.ProcessHolder; + +import java.util.HashMap; + +import static com.sun.codemodel.JExpr._super; + +public class OnActivityResultHolder { + + private EComponentHolder holder; + private JBlock afterSuperBlock; + private JSwitch zwitch; + private JVar requestCodeParam; + private JVar dataParam; + private JVar resultCodeParam; + private HashMap caseBlocks = new HashMap(); + + public OnActivityResultHolder(EComponentHolder holder) { + this.holder = holder; + } + + public JVar getRequestCodeParam() { + if (requestCodeParam == null) { + setOnActivityResult(); + } + return requestCodeParam; + } + + public JVar getDataParam() { + if (dataParam == null) { + setOnActivityResult(); + } + return dataParam; + } + + public JVar getResultCodeParam() { + if (dataParam == null) { + setOnActivityResult(); + } + return resultCodeParam; + } + + public JBlock getCaseBlock(int requestCode) { + JBlock onActivityResultCaseBlock = caseBlocks.get(requestCode); + if (onActivityResultCaseBlock == null) { + onActivityResultCaseBlock = createCaseBlock(requestCode); + caseBlocks.put(requestCode, onActivityResultCaseBlock); + } + return onActivityResultCaseBlock; + } + + private JBlock createCaseBlock(int requestCode) { + JCase onActivityResultCase = getSwitch()._case(JExpr.lit(requestCode)); + JBlock onActivityResultCaseBlock = onActivityResultCase.body().block(); + onActivityResultCase.body()._break(); + return onActivityResultCaseBlock; + } + + public JSwitch getSwitch() { + if (zwitch == null) { + setSwitch(); + } + return zwitch; + } + + private void setSwitch() { + zwitch = getAfterSuperBlock()._switch(getRequestCodeParam()); + } + + public JBlock getAfterSuperBlock() { + if (afterSuperBlock == null) { + setOnActivityResult(); + } + return afterSuperBlock; + } + + private void setOnActivityResult() { + JMethod method = holder.getGeneratedClass().method(JMod.PUBLIC, codeModel().VOID, "onActivityResult"); + method.annotate(Override.class); + requestCodeParam = method.param(codeModel().INT, "requestCode"); + resultCodeParam = method.param(codeModel().INT, "resultCode"); + dataParam = method.param(classes().INTENT, "data"); + JBlock body = method.body(); + body.invoke(_super(), method).arg(requestCodeParam).arg(resultCodeParam).arg(dataParam); + afterSuperBlock = body.block(); + } + + private JCodeModel codeModel() { + return holder.codeModel(); + } + + public ProcessHolder.Classes classes() { + return holder.classes(); + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java index de38e8dfb1..326e5aced0 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java @@ -26,10 +26,6 @@ public class RoboGuiceHolder { protected JVar currentConfig; protected JBlock onConfigurationChangedAfterSuperBlock; protected JBlock onContentChangedAfterSuperBlock; - protected JBlock onActivityResultAfterSuperBlock; - protected JVar requestCode; - protected JVar resultCode; - protected JVar data; public RoboGuiceHolder(EActivityHolder holder) { this.holder = holder; @@ -159,30 +155,18 @@ public JBlock getOnContentChangedAfterSuperBlock() { } public JBlock getOnActivityResultAfterSuperBlock() { - if (onActivityResultAfterSuperBlock == null) { - holder.setOnActivityResult(); - } - return onActivityResultAfterSuperBlock; + return holder.getOnActivityResultAfterSuperBlock(); } public JVar getRequestCode() { - if (requestCode == null) { - holder.setOnActivityResult(); - } - return requestCode; + return holder.getOnActivityResultRequestCodeParam(); } public JVar getResultCode() { - if (resultCode == null) { - holder.setOnActivityResult(); - } - return resultCode; + return holder.getOnActivityResultResultCodeParam(); } public JVar getData() { - if (data == null) { - holder.setOnActivityResult(); - } - return data; + return holder.getOnActivityResultDataParam(); } } From 13b13bf71660b49c46b46bff62a3728cf279c811 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 6 Jun 2013 14:46:17 +0200 Subject: [PATCH 67/86] Implement HierarchyViewerSupportHandler --- .../handler/AnnotationHandlers.java | 1 + .../HierarchyViewerSupportHandler.java | 44 +++++++++++++++ .../holder/EActivityHolder.java | 53 ++++++++++++------- .../holder/RoboGuiceHolder.java | 6 +-- 4 files changed, 81 insertions(+), 23 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HierarchyViewerSupportHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 736b6fca3d..0ad3d83c90 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -86,6 +86,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new InstanceStateHandler(processingEnvironment)); add(new HttpsClientHandler(processingEnvironment)); add(new OnActivityResultHandler(processingEnvironment)); + add(new HierarchyViewerSupportHandler(processingEnvironment)); /* * Any view injection or listener binding should occur before diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HierarchyViewerSupportHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HierarchyViewerSupportHandler.java new file mode 100644 index 0000000000..0c5228a56e --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HierarchyViewerSupportHandler.java @@ -0,0 +1,44 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JInvocation; +import org.androidannotations.annotations.HierarchyViewerSupport; +import org.androidannotations.api.ViewServer; +import org.androidannotations.holder.EActivityHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + +import static com.sun.codemodel.JExpr._this; + +public class HierarchyViewerSupportHandler extends BaseAnnotationHandler { + + public HierarchyViewerSupportHandler(ProcessingEnvironment processingEnvironment) { + super(HierarchyViewerSupport.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.hasEActivity(element, validatedElements, valid); + + validatorHelper.isDebuggable(element, androidManifest, valid); + + validatorHelper.hasInternetPermission(element, androidManifest, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EActivityHolder holder) throws Exception { + holder.generateApiClass(element, ViewServer.class); + + JInvocation viewServerInvocation = holder.classes().VIEW_SERVER.staticInvoke("get").arg(_this()); + + holder.getOnViewChangedBody().invoke(viewServerInvocation, "addWindow").arg(_this()); + holder.getOnDestroyAfterSuperBlock().invoke(viewServerInvocation, "removeWindow").arg(_this()); + holder.getOnResumeAfterSuperBlock().invoke(viewServerInvocation, "setFocusedWindow").arg(_this()); + } +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java index 705d88ab66..9723d18c00 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java @@ -45,6 +45,8 @@ public class EActivityHolder extends EComponentWithViewSupportHolder implements private JMethod getLastNonConfigurationInstance; private JBlock onRetainNonConfigurationInstanceBindBlock; private JVar onRetainNonConfigurationInstance; + private JBlock onDestroyAfterSuperBlock; + private JBlock onResumeAfterSuperBlock; public EActivityHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); @@ -97,27 +99,27 @@ protected void setOnStart() { JMethod method = generatedClass.method(JMod.PUBLIC, codeModel().VOID, "onStart"); method.annotate(Override.class); JBlock body = method.body(); - roboGuiceHolder.onStartBeforeSuperBlock = body.block(); + getRoboGuiceHolder().onStartBeforeSuperBlock = body.block(); body.invoke(_super(), method); - roboGuiceHolder.onStartAfterSuperBlock = body.block(); + getRoboGuiceHolder().onStartAfterSuperBlock = body.block(); } protected void setOnRestart() { JMethod method = generatedClass.method(JMod.PUBLIC, codeModel().VOID, "onRestart"); method.annotate(Override.class); JBlock body = method.body(); - roboGuiceHolder.onRestartBeforeSuperBlock = body.block(); + getRoboGuiceHolder().onRestartBeforeSuperBlock = body.block(); body.invoke(_super(), method); - roboGuiceHolder.onRestartAfterSuperBlock = body.block(); + getRoboGuiceHolder().onRestartAfterSuperBlock = body.block(); } protected void setOnResume() { JMethod method = generatedClass.method(JMod.PUBLIC, codeModel().VOID, "onResume"); method.annotate(Override.class); JBlock body = method.body(); - roboGuiceHolder.onResumeBeforeSuperBlock = body.block(); + getRoboGuiceHolder().onResumeBeforeSuperBlock = body.block(); body.invoke(_super(), method); - roboGuiceHolder.onResumeAfterSuperBlock = body.block(); + onResumeAfterSuperBlock = body.block(); } protected void setOnPause() { @@ -125,7 +127,7 @@ protected void setOnPause() { method.annotate(Override.class); JBlock body = method.body(); body.invoke(_super(), method); - roboGuiceHolder.onPauseAfterSuperBlock = body.block(); + getRoboGuiceHolder().onPauseAfterSuperBlock = body.block(); } protected void setOnNewIntent() { @@ -134,7 +136,7 @@ protected void setOnNewIntent() { JVar intent = method.param(classes().INTENT, "intent"); JBlock body = method.body(); body.invoke(_super(), method).arg(intent); - roboGuiceHolder.onNewIntentAfterSuperBlock = body.block(); + getRoboGuiceHolder().onNewIntentAfterSuperBlock = body.block(); } private void setSetIntent() { @@ -149,7 +151,7 @@ protected void setOnStop() { JMethod method = generatedClass.method(JMod.PUBLIC, codeModel().VOID, "onStop"); method.annotate(Override.class); JBlock body = method.body(); - roboGuiceHolder.onStopBeforeSuperBlock = body.block(); + getRoboGuiceHolder().onStopBeforeSuperBlock = body.block(); body.invoke(_super(), method); } @@ -157,8 +159,9 @@ protected void setOnDestroy() { JMethod method = generatedClass.method(JMod.PUBLIC, codeModel().VOID, "onDestroy"); method.annotate(Override.class); JBlock body = method.body(); - roboGuiceHolder.onDestroyBeforeSuperBlock = body.block(); + getRoboGuiceHolder().onDestroyBeforeSuperBlock = body.block(); body.invoke(_super(), method); + onDestroyAfterSuperBlock = body.block(); } protected void setOnConfigurationChanged() { @@ -166,11 +169,11 @@ protected void setOnConfigurationChanged() { method.annotate(Override.class); JClass configurationClass = classes().CONFIGURATION; JVar newConfig = method.param(configurationClass, "newConfig"); - roboGuiceHolder.newConfig = newConfig; + getRoboGuiceHolder().newConfig = newConfig; JBlock body = method.body(); - roboGuiceHolder.currentConfig = body.decl(configurationClass, "currentConfig", JExpr.invoke("getResources").invoke("getConfiguration")); + getRoboGuiceHolder().currentConfig = body.decl(configurationClass, "currentConfig", JExpr.invoke("getResources").invoke("getConfiguration")); body.invoke(_super(), method).arg(newConfig); - roboGuiceHolder.onConfigurationChangedAfterSuperBlock = body.block(); + getRoboGuiceHolder().onConfigurationChangedAfterSuperBlock = body.block(); } protected void setOnContentChanged() { @@ -178,7 +181,7 @@ protected void setOnContentChanged() { method.annotate(Override.class); JBlock body = method.body(); body.invoke(_super(), method); - roboGuiceHolder.onContentChangedAfterSuperBlock = body.block(); + getRoboGuiceHolder().onContentChangedAfterSuperBlock = body.block(); } private void setOnCreateOptionsMenu() { @@ -400,12 +403,12 @@ public RoboGuiceHolder getRoboGuiceHolder() { return roboGuiceHolder; } - protected void setScopeField() { - roboGuiceHolder.scope = getGeneratedClass().field(JMod.PRIVATE, classes().CONTEXT_SCOPE, "scope_"); + protected void setScopeField() { + getRoboGuiceHolder().scope = getGeneratedClass().field(JMod.PRIVATE, classes().CONTEXT_SCOPE, "scope_"); } protected void setEventManagerField() { - roboGuiceHolder.eventManager = generatedClass.field(JMod.PRIVATE, classes().EVENT_MANAGER, "eventManager_"); + getRoboGuiceHolder().eventManager = generatedClass.field(JMod.PRIVATE, classes().EVENT_MANAGER, "eventManager_"); } public void setGetInjector() { @@ -413,7 +416,7 @@ public void setGetInjector() { method.annotate(Override.class); JExpression castApplication = cast(classes().INJECTOR_PROVIDER, invoke("getApplication")); method.body()._return(castApplication.invoke("getInjector")); - roboGuiceHolder.getInjector = method; + getRoboGuiceHolder().getInjector = method; } @Override @@ -637,4 +640,18 @@ public JBlock getOnActivityResultAfterSuperBlock() { public JVar getOnActivityResultRequestCodeParam() { return onActivityResultHolder.getRequestCodeParam(); } + + public JBlock getOnDestroyAfterSuperBlock() { + if (onDestroyAfterSuperBlock == null) { + setOnDestroy(); + } + return onDestroyAfterSuperBlock; + } + + public JBlock getOnResumeAfterSuperBlock() { + if (onResumeAfterSuperBlock == null) { + setOnResume(); + } + return onResumeAfterSuperBlock; + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java index 326e5aced0..05339be771 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java @@ -17,7 +17,6 @@ public class RoboGuiceHolder { protected JBlock onStartBeforeSuperBlock; protected JBlock onStartAfterSuperBlock; protected JBlock onResumeBeforeSuperBlock; - protected JBlock onResumeAfterSuperBlock; protected JBlock onPauseAfterSuperBlock; protected JBlock onNewIntentAfterSuperBlock; protected JBlock onStopBeforeSuperBlock; @@ -92,10 +91,7 @@ public JBlock getOnResumeBeforeSuperBlock() { } public JBlock getOnResumeAfterSuperBlock() { - if (onResumeAfterSuperBlock == null) { - holder.setOnResume(); - } - return onResumeAfterSuperBlock; + return holder.getOnResumeAfterSuperBlock(); } public JBlock getOnPauseAfterSuperBlock() { From 5c698d868f817196832e3ec536a39f4b20f56d45 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 6 Jun 2013 15:02:05 +0200 Subject: [PATCH 68/86] Implement WindowFeatureHandler --- .../handler/AnnotationHandlers.java | 1 + .../handler/WindowFeatureHandler.java | 36 +++++++++++++++++++ 2 files changed, 37 insertions(+) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/WindowFeatureHandler.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 0ad3d83c90..f76f36f28d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -87,6 +87,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new HttpsClientHandler(processingEnvironment)); add(new OnActivityResultHandler(processingEnvironment)); add(new HierarchyViewerSupportHandler(processingEnvironment)); + add(new WindowFeatureHandler(processingEnvironment)); /* * Any view injection or listener binding should occur before diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/WindowFeatureHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/WindowFeatureHandler.java new file mode 100644 index 0000000000..c8af5203d5 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/WindowFeatureHandler.java @@ -0,0 +1,36 @@ +package org.androidannotations.handler; + +import com.sun.codemodel.JExpr; +import org.androidannotations.annotations.WindowFeature; +import org.androidannotations.holder.EActivityHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.validation.IsValid; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + +public class WindowFeatureHandler extends BaseAnnotationHandler { + + public WindowFeatureHandler(ProcessingEnvironment processingEnvironment) { + super(WindowFeature.class, processingEnvironment); + } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + + validatorHelper.hasEActivity(element, validatedElements, valid); + + return valid.isValid(); + } + + @Override + public void process(Element element, EActivityHolder holder) throws Exception { + WindowFeature annotation = element.getAnnotation(WindowFeature.class); + int[] features = annotation.value(); + + for (int feature : features) { + holder.getInit().body().invoke("requestWindowFeature").arg(JExpr.lit(feature)); + } + } +} From f214ddd87d8eb4b114d631e47947a039bfd2806f Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 6 Jun 2013 15:53:54 +0200 Subject: [PATCH 69/86] Remove unused classes and clean --- .../AndroidAnnotationProcessor.java | 273 +------------- .../generation/ApiCodeGenerator.java | 11 +- .../generation/SourceCodewriter.java | 12 +- .../handler/AbstractListenerHandler.java | 2 +- .../handler/AbstractRunnableHandler.java | 2 +- .../handler/AbstractSeekBarTouchHandler.java | 2 +- .../handler/AfterInjectHandler.java | 2 +- .../handler/AfterTextChangeHandler.java | 2 +- .../handler/AfterViewsHandler.java | 2 +- .../handler/AnnotationHandlers.java | 8 +- .../handler/AppHandler.java | 2 +- .../handler/BeanHandler.java | 2 +- .../handler/BeforeTextChangeHandler.java | 2 +- .../handler/CheckedChangeHandler.java | 2 +- .../handler/ClickHandler.java | 2 +- .../handler/CustomTitleHandler.java | 2 +- .../handler/EActivityHandler.java | 2 +- .../handler/EApplicationHandler.java | 3 +- .../handler/EBeanHandler.java | 2 +- .../handler/EFragmentHandler.java | 3 +- .../handler/EProviderHandler.java | 2 +- .../handler/EReceiverHandler.java | 2 +- .../handler/EServiceHandler.java | 2 +- .../handler/EViewGroupHandler.java | 2 +- .../handler/EViewHandler.java | 2 +- .../handler/ExtraHandler.java | 2 +- .../handler/FocusChangeHandler.java | 2 +- .../handler/FragmentArgHandler.java | 2 +- .../handler/FragmentByIdHandler.java | 2 +- .../handler/FragmentByTagHandler.java | 2 +- .../handler/FromHtmlHandler.java | 2 +- .../handler/FullscreenHandler.java | 2 +- .../HierarchyViewerSupportHandler.java | 2 +- .../handler/HttpsClientHandler.java | 2 +- .../handler/InstanceStateHandler.java | 2 +- .../handler/ItemClickHandler.java | 2 +- .../handler/ItemLongClickHandler.java | 2 +- .../handler/ItemSelectHandler.java | 2 +- .../handler/LongClickHandler.java | 2 +- .../handler/NoTitleHandler.java | 2 +- .../NonConfigurationInstanceHandler.java | 2 +- .../handler/OnActivityResultHandler.java | 2 +- .../handler/OptionsItemHandler.java | 2 +- .../handler/OptionsMenuHandler.java | 2 +- .../handler/OptionsMenuItemHandler.java | 2 +- .../handler/OrmLiteDaoHandler.java | 2 +- .../handler/PrefHandler.java | 2 +- .../handler/ProduceHandler.java | 2 +- .../handler/ResHandler.java | 3 +- .../handler/RoboGuiceHandler.java | 2 +- .../handler/RootContextHanlder.java | 2 +- .../handler/SeekBarProgressChangeHandler.java | 2 +- .../handler/SharedPrefHandler.java | 2 +- .../handler/SubscribeHandler.java | 2 +- .../handler/SystemServiceHandler.java | 2 +- .../handler/TextChangeHandler.java | 2 +- .../handler/TouchHandler.java | 2 +- .../handler/TraceHandler.java | 2 +- .../handler/TransactionalHandler.java | 2 +- .../handler/ViewByIdHandler.java | 2 +- .../handler/WindowFeatureHandler.java | 2 +- .../handler/{ => rest}/DeleteHandler.java | 4 +- .../handler/rest/GetHandler.java | 2 +- .../handler/{ => rest}/HeadHandler.java | 4 +- .../handler/{ => rest}/OptionsHandler.java | 4 +- .../handler/{ => rest}/PostHandler.java | 4 +- .../handler/{ => rest}/PutHandler.java | 4 +- .../handler/rest/RestHandler.java | 2 +- .../handler/rest/RestMethodHandler.java | 2 +- .../{ => rest}/RestServiceHandler.java | 5 +- .../helper/APTCodeModelHelper.java | 262 +------------- ...lper.java => ActionBarSherlockHelper.java} | 32 +- .../helper/AndroidManifestFinder.java | 31 +- .../helper/AnnotationHelper.java | 72 +--- .../helper/BundleHelper.java | 15 +- .../helper/GreenDroidConstants.java | 41 --- .../androidannotations/helper/HasTarget.java | 23 -- .../helper/IdAnnotationHelper.java | 22 -- .../helper/IdValidatorHelper.java | 11 +- .../helper/OnSeekBarChangeListenerHelper.java | 101 ------ .../helper/RestAnnotationHelper.java | 2 +- .../helper/TargetAnnotationHelper.java | 6 +- .../helper/TextWatcherHelper.java | 110 ------ .../helper/ValidatorHelper.java | 83 +---- .../helper/ValidatorParameterHelper.java | 9 +- .../helper/ViewNotifierHelper.java | 6 +- .../holder/EActivityHolder.java | 2 +- .../holder/EFragmentHolder.java | 4 +- .../androidannotations/model/AndroidRes.java | 13 - .../model/AndroidSystemServices.java | 20 +- .../model/ModelExtractor.java | 28 +- .../{validation => process}/IsValid.java | 2 +- .../process/ModelProcessor.java | 1 - .../OriginatingElements.java | 5 +- .../process/ProcessHolder.java | 1 - .../{helper => process}/TimeStats.java | 2 +- .../processing/AbstractListenerProcessor.java | 106 ------ .../AbstractOptionsMenuProcessor.java | 115 ------ .../AbstractTrackingTouchProcessor.java | 85 ----- .../processing/AfterInjectProcessor.java | 38 -- .../processing/AfterTextChangeProcessor.java | 116 ------ .../processing/AfterViewsProcessor.java | 38 -- .../processing/AppProcessor.java | 47 --- .../processing/BackgroundProcessor.java | 74 ---- .../processing/BeanProcessor.java | 86 ----- .../processing/BeforeTextChangeProcessor.java | 136 ------- .../processing/CheckedChangeProcessor.java | 87 ----- .../processing/ClickProcessor.java | 77 ---- .../processing/CustomTitleProcessor.java | 51 --- .../DecoratingElementProcessor.java | 31 -- .../processing/EActivityProcessor.java | 259 -------------- .../processing/EApplicationProcessor.java | 104 ------ .../processing/EBeanHolder.java | 217 ----------- .../processing/EBeanProcessor.java | 169 --------- .../processing/EBeansHolder.java | 252 ------------- .../processing/EFragmentProcessor.java | 216 ----------- .../processing/EProviderProcessor.java | 86 ----- .../processing/EReceiverProcessor.java | 94 ----- .../processing/EServiceProcessor.java | 95 ----- .../processing/EViewGroupProcessor.java | 150 -------- .../processing/EViewProcessor.java | 134 ------- .../processing/ExtraProcessor.java | 227 ------------ .../processing/FocusChangeProcessor.java | 85 ----- .../processing/FragmentArgProcessor.java | 150 -------- .../processing/FragmentByIdProcessor.java | 111 ------ .../processing/FragmentByTagProcessor.java | 112 ------ .../processing/FromHtmlProcessor.java | 63 ---- .../processing/FullscreenProcessor.java | 44 --- .../GeneratingElementProcessor.java | 27 -- .../HierarchyViewerSupportProcessor.java | 83 ----- .../processing/HttpsClientProcessor.java | 187 ---------- .../processing/InstanceStateProcessor.java | 166 --------- .../processing/ItemClickProcessor.java | 107 ------ .../processing/ItemLongClickProcessor.java | 118 ------ .../processing/ItemSelectedProcessor.java | 132 ------- .../processing/LongClickProcessor.java | 83 ----- .../processing/ModelProcessor.java | 144 -------- .../processing/NoTitleProcessor.java | 40 --- .../processing/NonConfigurationHolder.java | 36 -- .../NonConfigurationInstanceProcessor.java | 159 -------- .../processing/OnActivityResultProcessor.java | 138 ------- .../OnSeekBarChangeListenerHolder.java | 44 --- .../processing/OptionsItemProcessor.java | 127 ------- .../processing/OptionsMenuItemProcessor.java | 58 --- .../processing/OptionsMenuProcessor.java | 58 --- .../processing/OrmLiteDaoProcessor.java | 102 ------ .../processing/PrefProcessor.java | 84 ----- .../processing/ProduceProcessor.java | 48 --- .../processing/ResProcessor.java | 88 ----- .../processing/RestServiceProcessor.java | 53 --- .../processing/RoboGuiceProcessor.java | 287 --------------- .../processing/RootContextProcessor.java | 58 --- .../SeekBarProgressChangeProcessor.java | 116 ------ .../SeekBarTouchStartProcessor.java | 43 --- .../processing/SeekBarTouchStopProcessor.java | 44 --- .../processing/SharedPrefProcessor.java | 338 ------------------ .../processing/SubscribeProcessor.java | 48 --- .../processing/SystemServiceProcessor.java | 59 --- .../processing/TextChangeProcessor.java | 137 ------- .../processing/TextWatcherHolder.java | 43 --- .../processing/TouchProcessor.java | 89 ----- .../processing/TraceProcessor.java | 152 -------- .../processing/TransactionalProcessor.java | 98 ----- .../processing/UiThreadProcessor.java | 73 ---- .../processing/ViewByIdProcessor.java | 61 ---- .../processing/ViewChangedHolder.java | 47 --- .../processing/WindowFeatureProcessor.java | 42 --- .../processing/rest/DeleteProcessor.java | 49 --- .../processing/rest/GetPostProcessor.java | 283 --------------- .../processing/rest/GetProcessor.java | 72 ---- .../processing/rest/HeadProcessor.java | 62 ---- .../processing/rest/MethodProcessor.java | 270 -------------- .../rest/MethodProcessorHolder.java | 97 ----- .../processing/rest/OptionsProcessor.java | 72 ---- .../processing/rest/PostProcessor.java | 40 --- .../processing/rest/PutProcessor.java | 55 --- .../rest/RestImplementationHolder.java | 29 -- .../rest/RestImplementationsHolder.java | 42 --- .../processing/rest/RestProcessor.java | 188 ---------- .../rclass/CoumpoundInnerClass.java | 21 +- .../rclass/IRInnerClass.java | 5 - .../rclass/RInnerClass.java | 27 -- .../AbstractSeekBarTouchValidator.java | 84 ----- .../validation/AfterInjectValidator.java | 61 ---- .../validation/AfterTextChangeValidator.java | 98 ----- .../validation/AfterViewsValidator.java | 61 ---- .../validation/AppValidator.java | 54 --- .../validation/BeanValidator.java | 55 --- .../validation/BeforeTextChangeValidator.java | 108 ------ .../validation/CheckedChangeValidator.java | 72 ---- .../validation/ClickValidator.java | 67 ---- .../validation/CustomTitleValidator.java | 51 --- .../validation/EActivityValidator.java | 62 ---- .../validation/EApplicationValidator.java | 57 --- .../validation/EBeanValidator.java | 54 --- .../validation/EFragmentValidator.java | 61 ---- .../validation/EProviderValidator.java | 57 --- .../validation/EReceiverValidator.java | 58 --- .../validation/EServiceValidator.java | 57 --- .../validation/EViewGroupValidator.java | 58 --- .../validation/EViewValidator.java | 53 --- .../validation/ElementValidator.java | 37 -- .../validation/ExtraValidator.java | 56 --- .../validation/FocusChangeValidator.java | 67 ---- .../validation/FragmentArgValidator.java | 51 --- .../validation/FragmentByIdValidator.java | 60 ---- .../validation/FragmentByTagValidator.java | 55 --- .../validation/FromHtmlValidator.java | 57 --- .../validation/FullscreenValidator.java | 50 --- .../HierarchyViewerSupportValidator.java | 57 --- .../validation/HttpsClientValidator.java | 57 --- .../validation/InstanceStateValidator.java | 54 --- .../validation/ItemClickValidator.java | 67 ---- .../validation/ItemLongClickValidator.java | 67 ---- .../validation/ItemSelectedValidator.java | 69 ---- .../validation/LongClickValidator.java | 67 ---- .../validation/ModelValidator.java | 63 ---- .../validation/NoTitleValidator.java | 50 --- .../NonConfigurationInstanceValidator.java | 52 --- .../validation/OnActivityResultValidator.java | 101 ------ .../validation/OptionsItemValidator.java | 74 ---- .../validation/OptionsMenuItemValidator.java | 64 ---- .../validation/OptionsMenuValidator.java | 55 --- .../validation/OrmLiteDaoValidator.java | 60 ---- .../validation/PrefValidator.java | 54 --- .../validation/ProduceValidator.java | 71 ---- .../validation/ResValidator.java | 63 ---- .../validation/RestServiceValidator.java | 55 --- .../validation/RoboGuiceValidator.java | 52 --- .../validation/RootContextValidator.java | 54 --- .../validation/RunnableValidator.java | 64 ---- .../SeekBarProgressChangeValidator.java | 107 ------ .../SeekBarTouchStartValidator.java | 34 -- .../validation/SeekBarTouchStopValidator.java | 34 -- .../validation/SharedPrefValidator.java | 69 ---- .../validation/SubscribeValidator.java | 72 ---- .../validation/SystemServiceValidator.java | 57 --- .../validation/TextChangeValidator.java | 108 ------ .../validation/TouchValidator.java | 68 ---- .../validation/TraceValidator.java | 54 --- .../validation/TransactionalValidator.java | 61 ---- .../validation/ViewByIdValidator.java | 65 ---- .../validation/WindowFeatureValidator.java | 49 --- .../validation/rest/AcceptValidator.java | 69 ---- .../validation/rest/DeleteValidator.java | 66 ---- .../validation/rest/GetValidator.java | 66 ---- .../validation/rest/HeadValidator.java | 66 ---- .../validation/rest/OptionsValidator.java | 66 ---- .../validation/rest/PostValidator.java | 66 ---- .../validation/rest/PutValidator.java | 66 ---- .../validation/rest/RestValidator.java | 73 ---- 251 files changed, 167 insertions(+), 14320 deletions(-) rename AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/{ => rest}/DeleteHandler.java (92%) rename AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/{ => rest}/HeadHandler.java (93%) rename AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/{ => rest}/OptionsHandler.java (93%) rename AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/{ => rest}/PostHandler.java (95%) rename AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/{ => rest}/PutHandler.java (94%) rename AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/{ => rest}/RestServiceHandler.java (91%) rename AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/{ThirdPartyLibHelper.java => ActionBarSherlockHelper.java} (64%) delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/GreenDroidConstants.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/HasTarget.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/OnSeekBarChangeListenerHelper.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/TextWatcherHelper.java rename AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/{validation => process}/IsValid.java (94%) rename AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/{processing => process}/OriginatingElements.java (97%) rename AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/{helper => process}/TimeStats.java (98%) delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AbstractListenerProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AbstractOptionsMenuProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AbstractTrackingTouchProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AfterInjectProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AfterTextChangeProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AfterViewsProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AppProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/BackgroundProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/BeanProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/BeforeTextChangeProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/CheckedChangeProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ClickProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/CustomTitleProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/DecoratingElementProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EActivityProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EApplicationProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EBeanHolder.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EBeanProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EBeansHolder.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EFragmentProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EProviderProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EReceiverProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EServiceProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EViewGroupProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EViewProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ExtraProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FocusChangeProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FragmentArgProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FragmentByIdProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FragmentByTagProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FromHtmlProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FullscreenProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/GeneratingElementProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/HierarchyViewerSupportProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/HttpsClientProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/InstanceStateProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ItemClickProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ItemLongClickProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ItemSelectedProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/LongClickProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ModelProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/NoTitleProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/NonConfigurationHolder.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/NonConfigurationInstanceProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OnActivityResultProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OnSeekBarChangeListenerHolder.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OptionsItemProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OptionsMenuItemProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OptionsMenuProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OrmLiteDaoProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/PrefProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ProduceProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ResProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/RestServiceProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/RoboGuiceProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/RootContextProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/SeekBarProgressChangeProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/SeekBarTouchStartProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/SeekBarTouchStopProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/SharedPrefProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/SubscribeProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/SystemServiceProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TextChangeProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TextWatcherHolder.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TouchProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TraceProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TransactionalProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/UiThreadProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ViewByIdProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ViewChangedHolder.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/WindowFeatureProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/DeleteProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/GetPostProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/GetProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/HeadProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/MethodProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/MethodProcessorHolder.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/OptionsProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/PostProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/PutProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/RestImplementationHolder.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/RestImplementationsHolder.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/RestProcessor.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AbstractSeekBarTouchValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AfterInjectValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AfterTextChangeValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AfterViewsValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AppValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/BeanValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/BeforeTextChangeValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/CheckedChangeValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ClickValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/CustomTitleValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EActivityValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EApplicationValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EBeanValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EFragmentValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EProviderValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EReceiverValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EServiceValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EViewGroupValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EViewValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ElementValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ExtraValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FocusChangeValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FragmentArgValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FragmentByIdValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FragmentByTagValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FromHtmlValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FullscreenValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/HierarchyViewerSupportValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/HttpsClientValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/InstanceStateValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ItemClickValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ItemLongClickValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ItemSelectedValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/LongClickValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ModelValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/NoTitleValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/NonConfigurationInstanceValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OnActivityResultValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OptionsItemValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OptionsMenuItemValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OptionsMenuValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OrmLiteDaoValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/PrefValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ProduceValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ResValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/RestServiceValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/RoboGuiceValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/RootContextValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/RunnableValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SeekBarProgressChangeValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SeekBarTouchStartValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SeekBarTouchStopValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SharedPrefValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SubscribeValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SystemServiceValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TextChangeValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TouchValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TraceValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TransactionalValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ViewByIdValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/WindowFeatureValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/AcceptValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/DeleteValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/GetValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/HeadValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/OptionsValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/PostValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/PutValidator.java delete mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/RestValidator.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java index b1da3a18dc..126dcd763c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java @@ -20,7 +20,7 @@ import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.AndroidManifestFinder; import org.androidannotations.helper.Option; -import org.androidannotations.helper.TimeStats; +import org.androidannotations.process.TimeStats; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; import org.androidannotations.model.AnnotationElementsHolder; @@ -40,7 +40,6 @@ import java.io.IOException; import java.io.PrintWriter; import java.io.StringWriter; -import java.util.Map; import java.util.Set; import static org.androidannotations.helper.AndroidManifestFinder.ANDROID_MANIFEST_FILE_OPTION; @@ -162,97 +161,6 @@ private AnnotationElements validateAnnotations(AnnotationElementsHolder extracte return validatedAnnotations; } - /* - private ModelValidator buildModelValidator(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) { - ModelValidator modelValidator = new ModelValidator(); - modelValidator.register(new EApplicationValidator(processingEnv, androidManifest)); - modelValidator.register(new EActivityValidator(processingEnv, rClass, androidManifest)); - modelValidator.register(new EServiceValidator(processingEnv, androidManifest)); - modelValidator.register(new EReceiverValidator(processingEnv, androidManifest)); - modelValidator.register(new EProviderValidator(processingEnv, androidManifest)); - modelValidator.register(new EFragmentValidator(processingEnv, rClass)); - modelValidator.register(new EViewGroupValidator(processingEnv, rClass)); - modelValidator.register(new EViewValidator(processingEnv)); - modelValidator.register(new EBeanValidator(processingEnv)); - modelValidator.register(new RoboGuiceValidator(processingEnv)); - modelValidator.register(new ViewByIdValidator(processingEnv, rClass)); - modelValidator.register(new FragmentByIdValidator(processingEnv, rClass)); - modelValidator.register(new FragmentByTagValidator(processingEnv)); - modelValidator.register(new FromHtmlValidator(processingEnv, rClass)); - 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)); - for (AndroidRes androidRes : AndroidRes.values()) { - modelValidator.register(new ResValidator(androidRes, processingEnv, rClass)); - } - modelValidator.register(new TransactionalValidator(processingEnv)); - modelValidator.register(new ExtraValidator(processingEnv)); - modelValidator.register(new FragmentArgValidator(processingEnv)); - modelValidator.register(new SystemServiceValidator(processingEnv, androidSystemServices)); - modelValidator.register(new SharedPrefValidator(processingEnv)); - modelValidator.register(new PrefValidator(processingEnv)); - modelValidator.register(new RestValidator(processingEnv, androidManifest)); - modelValidator.register(new DeleteValidator(processingEnv)); - modelValidator.register(new GetValidator(processingEnv)); - modelValidator.register(new HeadValidator(processingEnv)); - modelValidator.register(new OptionsValidator(processingEnv)); - modelValidator.register(new PostValidator(processingEnv)); - modelValidator.register(new PutValidator(processingEnv)); - modelValidator.register(new AcceptValidator(processingEnv)); - modelValidator.register(new AppValidator(processingEnv)); - modelValidator.register(new OptionsMenuValidator(processingEnv, rClass)); - modelValidator.register(new OptionsMenuItemValidator(processingEnv, rClass)); - modelValidator.register(new OptionsItemValidator(processingEnv, rClass)); - modelValidator.register(new NoTitleValidator(processingEnv)); - modelValidator.register(new WindowFeatureValidator(processingEnv)); - modelValidator.register(new CustomTitleValidator(processingEnv, rClass)); - modelValidator.register(new FullscreenValidator(processingEnv)); - modelValidator.register(new RestServiceValidator(processingEnv)); - modelValidator.register(new RootContextValidator(processingEnv)); - modelValidator.register(new NonConfigurationInstanceValidator(processingEnv)); - modelValidator.register(new BeanValidator(processingEnv)); - modelValidator.register(new AfterInjectValidator(processingEnv)); - modelValidator.register(new BeforeTextChangeValidator(processingEnv, rClass)); - modelValidator.register(new TextChangeValidator(processingEnv, rClass)); - modelValidator.register(new AfterTextChangeValidator(processingEnv, rClass)); - modelValidator.register(new SeekBarProgressChangeValidator(processingEnv, rClass)); - modelValidator.register(new SeekBarTouchStartValidator(processingEnv, rClass)); - modelValidator.register(new SeekBarTouchStopValidator(processingEnv, rClass)); - /* - * Any view injection or listener binding should occur before - * AfterViewsValidator - * - modelValidator.register(new AfterViewsValidator(processingEnv)); - modelValidator.register(new TraceValidator(processingEnv)); - modelValidator.register(new SubscribeValidator(processingEnv)); - modelValidator.register(new ProduceValidator(processingEnv)); - modelValidator.register(new RunnableValidator(UiThread.class.getName(), processingEnv)); - modelValidator.register(new RunnableValidator(Background.class.getName(), processingEnv)); - modelValidator.register(new InstanceStateValidator(processingEnv)); - modelValidator.register(new OrmLiteDaoValidator(processingEnv, rClass)); - modelValidator.register(new HttpsClientValidator(processingEnv, rClass)); - modelValidator.register(new OnActivityResultValidator(processingEnv, rClass)); - modelValidator.register(new HierarchyViewerSupportValidator(processingEnv, androidManifest)); - - return modelValidator; - } - */ - - private boolean traceActivated() { - Map options = processingEnv.getOptions(); - if (options.containsKey(TRACE_OPTION)) { - String trace = options.get(TRACE_OPTION); - return !"false".equals(trace); - } else { - return true; - } - } - private ModelProcessor.ProcessResult processAnnotations(AnnotationElements validatedModel) throws Exception { timeStats.start("Process Annotations"); annotationHandlers.setValidatedModel(validatedModel); @@ -262,88 +170,6 @@ private ModelProcessor.ProcessResult processAnnotations(AnnotationElements valid return processResult; } - /* - private ModelProcessor buildModelProcessor(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest, AnnotationElements validatedModel) { - ModelProcessor modelProcessor = new ModelProcessor(); - modelProcessor.register(new EApplicationProcessor()); - modelProcessor.register(new EActivityProcessor(processingEnv, rClass)); - modelProcessor.register(new EServiceProcessor()); - modelProcessor.register(new EReceiverProcessor()); - modelProcessor.register(new EProviderProcessor()); - modelProcessor.register(new EFragmentProcessor(processingEnv, rClass)); - modelProcessor.register(new EViewGroupProcessor(processingEnv, rClass)); - modelProcessor.register(new EViewProcessor()); - modelProcessor.register(new EBeanProcessor()); - modelProcessor.register(new SharedPrefProcessor(processingEnv, rClass)); - modelProcessor.register(new PrefProcessor(validatedModel)); - modelProcessor.register(new RoboGuiceProcessor()); - modelProcessor.register(new ViewByIdProcessor(processingEnv, rClass)); - modelProcessor.register(new FragmentByIdProcessor(processingEnv, rClass)); - modelProcessor.register(new FragmentByTagProcessor(processingEnv)); - modelProcessor.register(new FromHtmlProcessor(processingEnv, rClass)); - 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)); - for (AndroidRes androidRes : AndroidRes.values()) { - modelProcessor.register(new ResProcessor(processingEnv, androidRes, rClass)); - } - modelProcessor.register(new TransactionalProcessor()); - modelProcessor.register(new ExtraProcessor(processingEnv)); - modelProcessor.register(new FragmentArgProcessor(processingEnv)); - modelProcessor.register(new SystemServiceProcessor(androidSystemServices)); - RestImplementationsHolder restImplementationsHolder = new RestImplementationsHolder(); - modelProcessor.register(new RestProcessor(processingEnv, restImplementationsHolder)); - modelProcessor.register(new GetProcessor(processingEnv, restImplementationsHolder)); - modelProcessor.register(new PostProcessor(processingEnv, restImplementationsHolder)); - modelProcessor.register(new PutProcessor(processingEnv, restImplementationsHolder)); - modelProcessor.register(new DeleteProcessor(processingEnv, restImplementationsHolder)); - modelProcessor.register(new HeadProcessor(processingEnv, restImplementationsHolder)); - modelProcessor.register(new OptionsProcessor(processingEnv, restImplementationsHolder)); - modelProcessor.register(new AppProcessor()); - modelProcessor.register(new OptionsMenuProcessor(processingEnv, rClass)); - modelProcessor.register(new OptionsMenuItemProcessor(processingEnv, rClass)); - modelProcessor.register(new OptionsItemProcessor(processingEnv, rClass)); - modelProcessor.register(new NoTitleProcessor()); - modelProcessor.register(new WindowFeatureProcessor()); - modelProcessor.register(new CustomTitleProcessor(processingEnv, rClass)); - modelProcessor.register(new FullscreenProcessor()); - modelProcessor.register(new RestServiceProcessor()); - modelProcessor.register(new OrmLiteDaoProcessor(processingEnv)); - modelProcessor.register(new RootContextProcessor()); - modelProcessor.register(new NonConfigurationInstanceProcessor(processingEnv)); - modelProcessor.register(new BeanProcessor(processingEnv)); - modelProcessor.register(new BeforeTextChangeProcessor(processingEnv, rClass)); - modelProcessor.register(new TextChangeProcessor(processingEnv, rClass)); - modelProcessor.register(new AfterTextChangeProcessor(processingEnv, rClass)); - modelProcessor.register(new SeekBarProgressChangeProcessor(processingEnv, rClass)); - modelProcessor.register(new SeekBarTouchStartProcessor(processingEnv, rClass)); - modelProcessor.register(new SeekBarTouchStopProcessor(processingEnv, rClass)); - /* - * Any view injection or listener binding should occur before - * AfterViewsProcessor - * - modelProcessor.register(new AfterViewsProcessor()); - if (traceActivated()) { - modelProcessor.register(new TraceProcessor()); - } - modelProcessor.register(new SubscribeProcessor()); - modelProcessor.register(new ProduceProcessor()); - modelProcessor.register(new UiThreadProcessor()); - modelProcessor.register(new BackgroundProcessor()); - modelProcessor.register(new AfterInjectProcessor()); - modelProcessor.register(new InstanceStateProcessor(processingEnv)); - modelProcessor.register(new HttpsClientProcessor(rClass)); - modelProcessor.register(new OnActivityResultProcessor(processingEnv, rClass)); - modelProcessor.register(new HierarchyViewerSupportProcessor()); - return modelProcessor; - } - */ - private void generateSources(ModelProcessor.ProcessResult processResult) throws IOException { timeStats.start("Generate Sources"); Messager messager = processingEnv.getMessager(); @@ -379,102 +205,5 @@ private String stackTraceToString(Throwable e) { @Override public Set getSupportedAnnotationTypes() { return annotationHandlers.getSupportedAnnotationTypes(); - /* - if (supportedAnnotationNames == null) { - Class[] annotationClassesArray = { // - // - EActivity.class, // - App.class, // - EViewGroup.class, // - EView.class, // - AfterViews.class, // - RoboGuice.class, // - ViewById.class, // - Click.class, // - LongClick.class, // - ItemClick.class, // - ItemLongClick.class, // - Touch.class, // - ItemSelect.class, // - UiThread.class, // - Transactional.class, // - Background.class, // - Extra.class, // - SystemService.class, // - SharedPref.class, // - Pref.class, // - StringRes.class, // - ColorRes.class, // - AnimationRes.class, // - BooleanRes.class, // - ColorStateListRes.class, // - DimensionRes.class, // - DimensionPixelOffsetRes.class, // - DimensionPixelSizeRes.class, // - DrawableRes.class, // - IntArrayRes.class, // - IntegerRes.class, // - LayoutRes.class, // - MovieRes.class, // - TextRes.class, // - TextArrayRes.class, // - StringArrayRes.class, // - Rest.class, // - Get.class, // - Head.class, // - Options.class, // - Post.class, // - Put.class, // - Delete.class, // - Accept.class, // - FromHtml.class, // - OptionsMenu.class, // - OptionsMenuItem.class, // - OptionsItem.class, // - HtmlRes.class, // - NoTitle.class, // - WindowFeature.class, // - CustomTitle.class, // - Fullscreen.class, // - RestService.class, // - EBean.class, // - RootContext.class, // - Bean.class, // - AfterInject.class, // - EService.class, // - EReceiver.class, // - EProvider.class, // - Trace.class, // - InstanceState.class, // - NonConfigurationInstance.class, // - EApplication.class, // - EFragment.class, // - FragmentById.class, // - FragmentByTag.class, // - BeforeTextChange.class, // - TextChange.class, // - SeekBarProgressChange.class, // - SeekBarTouchStart.class, // - SeekBarTouchStop.class, // - AfterTextChange.class, // - OrmLiteDao.class, // - HttpsClient.class, // - FragmentArg.class, // - OnActivityResult.class, // - HierarchyViewerSupport.class // - }; - - Set set = new HashSet(annotationClassesArray.length); - for (Class annotationClass : annotationClassesArray) { - set.add(annotationClass.getName()); - } - - set.add(SUBSCRIBE); - set.add(PRODUCE); - - supportedAnnotationNames = Collections.unmodifiableSet(set); - } - return supportedAnnotationNames; - */ } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/ApiCodeGenerator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/ApiCodeGenerator.java index b93802f8d5..c347aa6a83 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/ApiCodeGenerator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/ApiCodeGenerator.java @@ -15,17 +15,16 @@ */ package org.androidannotations.generation; -import java.io.IOException; -import java.io.InputStream; -import java.io.OutputStream; -import java.util.Set; +import org.androidannotations.process.OriginatingElements; import javax.annotation.processing.Filer; import javax.annotation.processing.FilerException; import javax.lang.model.element.Element; import javax.tools.JavaFileObject; - -import org.androidannotations.processing.OriginatingElements; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.util.Set; public class ApiCodeGenerator { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/SourceCodewriter.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/SourceCodewriter.java index ef6933e534..3a31afc1a6 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/SourceCodewriter.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/SourceCodewriter.java @@ -15,8 +15,9 @@ */ package org.androidannotations.generation; -import java.io.IOException; -import java.io.OutputStream; +import com.sun.codemodel.CodeWriter; +import com.sun.codemodel.JPackage; +import org.androidannotations.process.OriginatingElements; import javax.annotation.processing.Filer; import javax.annotation.processing.FilerException; @@ -24,11 +25,8 @@ import javax.lang.model.element.Element; import javax.tools.Diagnostic.Kind; import javax.tools.JavaFileObject; - -import org.androidannotations.processing.OriginatingElements; - -import com.sun.codemodel.CodeWriter; -import com.sun.codemodel.JPackage; +import java.io.IOException; +import java.io.OutputStream; public class SourceCodewriter extends CodeWriter { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java index 60ca309443..c6a7dff5ae 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java @@ -9,7 +9,7 @@ import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.ProcessHolder; import org.androidannotations.rclass.IRClass; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractRunnableHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractRunnableHandler.java index 9ce960a595..6b7b57828d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractRunnableHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractRunnableHandler.java @@ -2,7 +2,7 @@ import org.androidannotations.holder.EComponentHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractSeekBarTouchHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractSeekBarTouchHandler.java index 9985c4d420..183a92ac3a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractSeekBarTouchHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractSeekBarTouchHandler.java @@ -9,7 +9,7 @@ import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; import org.androidannotations.rclass.IRClass; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterInjectHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterInjectHandler.java index d12c5f997b..93595e225d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterInjectHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterInjectHandler.java @@ -3,7 +3,7 @@ import org.androidannotations.annotations.AfterInject; import org.androidannotations.holder.EComponentHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterTextChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterTextChangeHandler.java index bd37a20524..e5a3f8175b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterTextChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterTextChangeHandler.java @@ -11,7 +11,7 @@ import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; import org.androidannotations.rclass.IRClass; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterViewsHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterViewsHandler.java index 01ac07c82c..617ea6279a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterViewsHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterViewsHandler.java @@ -3,7 +3,7 @@ import org.androidannotations.annotations.AfterViews; import org.androidannotations.holder.EComponentWithViewSupportHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index f76f36f28d..4289bac905 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -1,7 +1,6 @@ package org.androidannotations.handler; -import org.androidannotations.handler.rest.GetHandler; -import org.androidannotations.handler.rest.RestHandler; +import org.androidannotations.handler.rest.*; import org.androidannotations.helper.AndroidManifest; import org.androidannotations.holder.GeneratedClassHolder; import org.androidannotations.model.AndroidRes; @@ -89,10 +88,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new HierarchyViewerSupportHandler(processingEnvironment)); add(new WindowFeatureHandler(processingEnvironment)); - /* - * Any view injection or listener binding should occur before - * AfterViewsProcessor - */ + /* After injection methods must be after injections */ add(new AfterInjectHandler(processingEnvironment)); add(new AfterViewsHandler(processingEnvironment)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java index cde053f666..1387d20f3b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java @@ -7,7 +7,7 @@ import org.androidannotations.holder.EApplicationHolder; import org.androidannotations.holder.EComponentHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java index ce5d9cc0e4..cd42d4f2c5 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java @@ -11,7 +11,7 @@ import org.androidannotations.holder.EBeanHolder; import org.androidannotations.holder.EComponentHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeforeTextChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeforeTextChangeHandler.java index 7f7feaf0c9..0a2dc2a245 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeforeTextChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeforeTextChangeHandler.java @@ -11,7 +11,7 @@ import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; import org.androidannotations.rclass.IRClass; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CheckedChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CheckedChangeHandler.java index 63e3d0ff2e..26484fd70b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CheckedChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CheckedChangeHandler.java @@ -3,7 +3,7 @@ import com.sun.codemodel.*; import org.androidannotations.annotations.CheckedChange; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ClickHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ClickHandler.java index 90005f77f8..a1442eb7b5 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ClickHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ClickHandler.java @@ -3,7 +3,7 @@ import com.sun.codemodel.*; import org.androidannotations.annotations.Click; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java index 82197b92d2..0358ec3329 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java @@ -8,7 +8,7 @@ import org.androidannotations.holder.EActivityHolder; import org.androidannotations.model.AnnotationElements; import org.androidannotations.rclass.IRClass; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EActivityHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EActivityHandler.java index 421d7d1322..5f11b3dc78 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EActivityHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EActivityHandler.java @@ -10,7 +10,7 @@ import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.ProcessHolder; import org.androidannotations.rclass.IRClass; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EApplicationHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EApplicationHandler.java index e661a81ab5..ac9ae69bbb 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EApplicationHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EApplicationHandler.java @@ -2,10 +2,9 @@ import org.androidannotations.annotations.EApplication; import org.androidannotations.holder.EApplicationHolder; -import org.androidannotations.holder.EComponentHolder; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.ProcessHolder; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EBeanHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EBeanHandler.java index 9958c2f367..d486d60fb1 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EBeanHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EBeanHandler.java @@ -4,7 +4,7 @@ import org.androidannotations.holder.EBeanHolder; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.ProcessHolder; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EFragmentHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EFragmentHandler.java index 6e4d2184b0..8a8d5ab320 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EFragmentHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EFragmentHandler.java @@ -7,12 +7,11 @@ import org.androidannotations.annotations.EFragment; import org.androidannotations.helper.IdAnnotationHelper; import org.androidannotations.helper.IdValidatorHelper; -import org.androidannotations.holder.EComponentHolder; import org.androidannotations.holder.EFragmentHolder; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.ProcessHolder; import org.androidannotations.rclass.IRClass; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EProviderHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EProviderHandler.java index 8567f53fa3..d0355a49f9 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EProviderHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EProviderHandler.java @@ -4,7 +4,7 @@ import org.androidannotations.holder.EProviderHolder; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.ProcessHolder; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EReceiverHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EReceiverHandler.java index 1b7e225932..6460918d02 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EReceiverHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EReceiverHandler.java @@ -4,7 +4,7 @@ import org.androidannotations.holder.EReceiverHolder; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.ProcessHolder; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EServiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EServiceHandler.java index 5212db814d..ced6959514 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EServiceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EServiceHandler.java @@ -4,7 +4,7 @@ import org.androidannotations.holder.EServiceHolder; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.ProcessHolder; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewGroupHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewGroupHandler.java index 2b36188b9f..6db4920320 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewGroupHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewGroupHandler.java @@ -11,7 +11,7 @@ import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.ProcessHolder; import org.androidannotations.rclass.IRClass; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewHandler.java index 98073e5f77..73a9658f11 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewHandler.java @@ -4,7 +4,7 @@ import org.androidannotations.holder.EViewHolder; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.ProcessHolder; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java index fddec3ae63..d5c0c27d70 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java @@ -9,7 +9,7 @@ import org.androidannotations.holder.HasExtras; import org.androidannotations.holder.HasIntentBuilder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FocusChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FocusChangeHandler.java index ee0e068a2e..e446fbcf3b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FocusChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FocusChangeHandler.java @@ -3,7 +3,7 @@ import com.sun.codemodel.*; import org.androidannotations.annotations.FocusChange; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentArgHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentArgHandler.java index 564ace5152..78a21c24b2 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentArgHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentArgHandler.java @@ -8,7 +8,7 @@ import org.androidannotations.helper.CaseHelper; import org.androidannotations.holder.EFragmentHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java index a4311bc200..662832df2e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java @@ -12,7 +12,7 @@ import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; import org.androidannotations.rclass.IRClass; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java index b112594ce3..a2d01b5fc2 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java @@ -10,7 +10,7 @@ import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; import org.androidannotations.rclass.IRClass; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java index fe70f38232..736e023d28 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java @@ -11,7 +11,7 @@ import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.ProcessHolder; import org.androidannotations.rclass.IRClass; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java index 33aecb4565..de78b75eed 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java @@ -4,7 +4,7 @@ import org.androidannotations.annotations.Fullscreen; import org.androidannotations.holder.EActivityHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HierarchyViewerSupportHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HierarchyViewerSupportHandler.java index 0c5228a56e..ada1b88680 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HierarchyViewerSupportHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HierarchyViewerSupportHandler.java @@ -5,7 +5,7 @@ import org.androidannotations.api.ViewServer; import org.androidannotations.holder.EActivityHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java index f790b66df9..f59ff79277 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java @@ -8,7 +8,7 @@ import org.androidannotations.process.ProcessHolder; import org.androidannotations.rclass.IRClass; import org.androidannotations.rclass.IRInnerClass; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/InstanceStateHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/InstanceStateHandler.java index a66460b050..3487f398c6 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/InstanceStateHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/InstanceStateHandler.java @@ -7,7 +7,7 @@ import org.androidannotations.helper.BundleHelper; import org.androidannotations.holder.HasInstanceState; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemClickHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemClickHandler.java index 26c21c04c1..a1ca6b372a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemClickHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemClickHandler.java @@ -3,7 +3,7 @@ import com.sun.codemodel.*; import org.androidannotations.annotations.ItemClick; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemLongClickHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemLongClickHandler.java index 6c91e85729..0f93dd3b42 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemLongClickHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemLongClickHandler.java @@ -3,7 +3,7 @@ import com.sun.codemodel.*; import org.androidannotations.annotations.ItemLongClick; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemSelectHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemSelectHandler.java index 342fec7485..939cb51cfb 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemSelectHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemSelectHandler.java @@ -3,7 +3,7 @@ import com.sun.codemodel.*; import org.androidannotations.annotations.ItemSelect; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/LongClickHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/LongClickHandler.java index 67b045685a..a19e3cec84 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/LongClickHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/LongClickHandler.java @@ -3,7 +3,7 @@ import com.sun.codemodel.*; import org.androidannotations.annotations.LongClick; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java index 084acefe9a..bd267515a2 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java @@ -4,7 +4,7 @@ import org.androidannotations.annotations.NoTitle; import org.androidannotations.holder.EActivityHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NonConfigurationInstanceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NonConfigurationInstanceHandler.java index 0354c0fa26..388755abd6 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NonConfigurationInstanceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NonConfigurationInstanceHandler.java @@ -8,7 +8,7 @@ import org.androidannotations.holder.EActivityHolder; import org.androidannotations.holder.NonConfigurationHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OnActivityResultHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OnActivityResultHandler.java index ee443f1110..0481cc3af9 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OnActivityResultHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OnActivityResultHandler.java @@ -8,7 +8,7 @@ import org.androidannotations.helper.CanonicalNameConstants; import org.androidannotations.holder.HasOnActivityResult; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsItemHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsItemHandler.java index 7cce5cd930..f4b9cfe17e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsItemHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsItemHandler.java @@ -12,7 +12,7 @@ import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; import org.androidannotations.rclass.IRClass; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuHandler.java index 932e33b49c..804be3ba65 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuHandler.java @@ -11,7 +11,7 @@ import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; import org.androidannotations.rclass.IRClass; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuItemHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuItemHandler.java index f12a2aebed..5f01d88fae 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuItemHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuItemHandler.java @@ -11,7 +11,7 @@ import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; import org.androidannotations.rclass.IRClass; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java index 3fe52a8bb1..100d780512 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java @@ -5,7 +5,7 @@ import org.androidannotations.helper.TargetAnnotationHelper; import org.androidannotations.holder.EComponentHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java index a033c37829..e3a8a0de17 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java @@ -7,7 +7,7 @@ import org.androidannotations.annotations.sharedpreferences.SharedPref; import org.androidannotations.holder.EComponentHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ProduceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ProduceHandler.java index a9246c24ec..3f12232878 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ProduceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ProduceHandler.java @@ -6,7 +6,7 @@ import org.androidannotations.helper.TargetAnnotationHelper; import org.androidannotations.holder.EComponentHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java index 07e626c0b3..9f1459e779 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java @@ -13,12 +13,11 @@ import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.ProcessHolder; import org.androidannotations.rclass.IRClass; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; import javax.lang.model.type.TypeMirror; -import javax.swing.text.html.HTML; import static com.sun.codemodel.JExpr.invoke; import static com.sun.codemodel.JExpr.ref; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java index c675e894c9..9be973ceb1 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java @@ -6,7 +6,7 @@ import org.androidannotations.holder.RoboGuiceHolder; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.ProcessHolder; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.AnnotationMirror; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java index 19739bbb65..ea434b1559 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java @@ -7,7 +7,7 @@ import org.androidannotations.helper.CanonicalNameConstants; import org.androidannotations.holder.EBeanHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarProgressChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarProgressChangeHandler.java index 01d37bb350..7777c0b66f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarProgressChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarProgressChangeHandler.java @@ -11,7 +11,7 @@ import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; import org.androidannotations.rclass.IRClass; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SharedPrefHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SharedPrefHandler.java index 3747877eb2..74573320b8 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SharedPrefHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SharedPrefHandler.java @@ -11,7 +11,7 @@ import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.ProcessHolder; import org.androidannotations.rclass.IRClass; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SubscribeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SubscribeHandler.java index b31f27f692..c54a3a37be 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SubscribeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SubscribeHandler.java @@ -6,7 +6,7 @@ import org.androidannotations.helper.TargetAnnotationHelper; import org.androidannotations.holder.EComponentHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java index 2d352eaf75..d1d8183019 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java @@ -5,7 +5,7 @@ import org.androidannotations.annotations.SystemService; import org.androidannotations.holder.EComponentHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TextChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TextChangeHandler.java index 60e87358e4..2fa3888ccd 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TextChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TextChangeHandler.java @@ -11,7 +11,7 @@ import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; import org.androidannotations.rclass.IRClass; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TouchHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TouchHandler.java index 94354791f6..654b477a8f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TouchHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TouchHandler.java @@ -3,7 +3,7 @@ import com.sun.codemodel.*; import org.androidannotations.annotations.Touch; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TraceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TraceHandler.java index 11f7804858..96860ab6e1 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TraceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TraceHandler.java @@ -6,7 +6,7 @@ import org.androidannotations.holder.EComponentHolder; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.ProcessHolder; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TransactionalHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TransactionalHandler.java index be3d420b43..895bd64f6b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TransactionalHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TransactionalHandler.java @@ -5,7 +5,7 @@ import org.androidannotations.helper.APTCodeModelHelper; import org.androidannotations.holder.EComponentHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java index f6287daaf6..b5ae7644de 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java @@ -10,7 +10,7 @@ import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; import org.androidannotations.rclass.IRClass; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/WindowFeatureHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/WindowFeatureHandler.java index c8af5203d5..92528d326b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/WindowFeatureHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/WindowFeatureHandler.java @@ -4,7 +4,7 @@ import org.androidannotations.annotations.WindowFeature; import org.androidannotations.holder.EActivityHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/DeleteHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/DeleteHandler.java similarity index 92% rename from AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/DeleteHandler.java rename to AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/DeleteHandler.java index b46ee8724d..0ae197a725 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/DeleteHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/DeleteHandler.java @@ -1,9 +1,9 @@ -package org.androidannotations.handler; +package org.androidannotations.handler.rest; import org.androidannotations.annotations.rest.Delete; import org.androidannotations.handler.rest.RestMethodHandler; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/GetHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/GetHandler.java index 537b23ab84..5301f8fcaf 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/GetHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/GetHandler.java @@ -5,7 +5,7 @@ import org.androidannotations.helper.CanonicalNameConstants; import org.androidannotations.holder.RestHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HeadHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/HeadHandler.java similarity index 93% rename from AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HeadHandler.java rename to AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/HeadHandler.java index 2c13c605d2..20352b2f97 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HeadHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/HeadHandler.java @@ -1,4 +1,4 @@ -package org.androidannotations.handler; +package org.androidannotations.handler.rest; import com.sun.codemodel.JClass; import com.sun.codemodel.JExpr; @@ -6,7 +6,7 @@ import org.androidannotations.annotations.rest.Head; import org.androidannotations.handler.rest.RestMethodHandler; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/OptionsHandler.java similarity index 93% rename from AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsHandler.java rename to AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/OptionsHandler.java index 0b689ea854..9f5308995e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/OptionsHandler.java @@ -1,10 +1,10 @@ -package org.androidannotations.handler; +package org.androidannotations.handler.rest; import com.sun.codemodel.JClass; import com.sun.codemodel.JInvocation; import org.androidannotations.annotations.rest.Options; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PostHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PostHandler.java similarity index 95% rename from AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PostHandler.java rename to AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PostHandler.java index 34a12b8d01..4b9b4e99c7 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PostHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PostHandler.java @@ -1,11 +1,11 @@ -package org.androidannotations.handler; +package org.androidannotations.handler.rest; import com.sun.codemodel.*; import org.androidannotations.annotations.rest.Post; import org.androidannotations.helper.CanonicalNameConstants; import org.androidannotations.holder.RestHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PutHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PutHandler.java similarity index 94% rename from AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PutHandler.java rename to AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PutHandler.java index 9706c3fb2f..220bb70838 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PutHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PutHandler.java @@ -1,4 +1,4 @@ -package org.androidannotations.handler; +package org.androidannotations.handler.rest; import com.sun.codemodel.JBlock; import com.sun.codemodel.JExpression; @@ -7,7 +7,7 @@ import org.androidannotations.handler.rest.RestMethodHandler; import org.androidannotations.holder.RestHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestHandler.java index 94fdee2b70..3447c6466b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestHandler.java @@ -10,7 +10,7 @@ import org.androidannotations.holder.RestHolder; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.ProcessHolder; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java index a99abdd788..ff30583936 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java @@ -6,7 +6,7 @@ import org.androidannotations.helper.RestAnnotationHelper; import org.androidannotations.holder.RestHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RestServiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestServiceHandler.java similarity index 91% rename from AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RestServiceHandler.java rename to AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestServiceHandler.java index 2593a058a4..95ae95d865 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RestServiceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestServiceHandler.java @@ -1,14 +1,15 @@ -package org.androidannotations.handler; +package org.androidannotations.handler.rest; import com.sun.codemodel.JBlock; import com.sun.codemodel.JExpr; import com.sun.codemodel.JFieldRef; import org.androidannotations.annotations.rest.Rest; import org.androidannotations.annotations.rest.RestService; +import org.androidannotations.handler.BaseAnnotationHandler; import org.androidannotations.helper.ModelConstants; import org.androidannotations.holder.EComponentHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java index f37b2a335b..bbddc1cf62 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java @@ -19,10 +19,7 @@ import org.androidannotations.holder.EComponentHolder; import org.androidannotations.holder.GeneratedClassHolder; import org.androidannotations.process.ProcessHolder; -import org.androidannotations.processing.EBeanHolder; -import org.androidannotations.processing.EBeansHolder.Classes; -import javax.lang.model.element.Element; import javax.lang.model.element.ExecutableElement; import javax.lang.model.element.VariableElement; import javax.lang.model.type.ArrayType; @@ -33,10 +30,6 @@ import java.util.ArrayList; import java.util.List; -import static com.sun.codemodel.JExpr.*; -import static com.sun.codemodel.JMod.*; -import static javax.lang.model.element.ElementKind.CONSTRUCTOR; - public class APTCodeModelHelper { public JClass typeMirrorToJClass(TypeMirror type, GeneratedClassHolder holder) { @@ -80,47 +73,6 @@ public JClass typeMirrorToJClass(TypeMirror type, GeneratedClassHolder holder) { } } - public JClass typeMirrorToJClass(TypeMirror type, EBeanHolder holder) { - - if (type instanceof DeclaredType) { - DeclaredType declaredType = (DeclaredType) type; - - String declaredTypeName = declaredType.asElement().toString(); - - JClass declaredClass = holder.refClass(declaredTypeName); - - List typeArguments = declaredType.getTypeArguments(); - - List typeArgumentJClasses = new ArrayList(); - for (TypeMirror typeArgument : typeArguments) { - typeArgumentJClasses.add(typeMirrorToJClass(typeArgument, holder)); - } - if (typeArgumentJClasses.size() > 0) { - declaredClass = declaredClass.narrow(typeArgumentJClasses); - } - - return declaredClass; - } else if (type instanceof WildcardType) { - // TODO : At his time (01/2013), it is not possible to handle the - // super bound because code model does not offer a way to model - // statement like " ? super X" - // (see http://java.net/jira/browse/CODEMODEL-11) - WildcardType wildcardType = (WildcardType) type; - - TypeMirror extendsBound = wildcardType.getExtendsBound(); - - return typeMirrorToJClass(extendsBound, holder).wildcard(); - } else if (type instanceof ArrayType) { - ArrayType arrayType = (ArrayType) type; - - JClass refClass = typeMirrorToJClass(arrayType.getComponentType(), holder); - - return refClass.array(); - } else { - return holder.refClass(type.toString()); - } - } - public static class Parameter { public final String name; public final JClass jClass; @@ -156,47 +108,7 @@ public JMethod overrideAnnotatedMethod(ExecutableElement executableElement, ECom for (VariableElement parameter : executableElement.getParameters()) { String parameterName = parameter.getSimpleName().toString(); JClass parameterClass = typeMirrorToJClass(parameter.asType(), holder); - JVar param = method.param(JMod.FINAL, parameterClass, parameterName); - } - - for (TypeMirror superThrownType : executableElement.getThrownTypes()) { - JClass thrownType = typeMirrorToJClass(superThrownType, holder); - method._throws(thrownType); - } - - callSuperMethod(method, holder, method.body()); - - return method; - } - - public JMethod overrideAnnotatedMethod(ExecutableElement executableElement, EBeanHolder holder) { - - String methodName = executableElement.getSimpleName().toString(); - - JClass returnType = typeMirrorToJClass(executableElement.getReturnType(), holder); - - List parameters = new ArrayList(); - for (VariableElement parameter : executableElement.getParameters()) { - String parameterName = parameter.getSimpleName().toString(); - JClass parameterClass = typeMirrorToJClass(parameter.asType(), holder); - parameters.add(new Parameter(parameterName, parameterClass)); - } - - JMethod existingMethod = findAlreadyGeneratedMethod(holder.generatedClass, methodName, parameters); - - if (existingMethod != null) { - return existingMethod; - } - - JMethod method = holder.generatedClass.method(JMod.PUBLIC, returnType, methodName); - method.annotate(Override.class); - - List methodParameters = new ArrayList(); - for (VariableElement parameter : executableElement.getParameters()) { - String parameterName = parameter.getSimpleName().toString(); - JClass parameterClass = typeMirrorToJClass(parameter.asType(), holder); - JVar param = method.param(JMod.FINAL, parameterClass, parameterName); - methodParameters.add(param); + method.param(JMod.FINAL, parameterClass, parameterName); } for (TypeMirror superThrownType : executableElement.getThrownTypes()) { @@ -242,22 +154,6 @@ public void callSuperMethod(JMethod superMethod, EComponentHolder holder, JBlock } } - public void callSuperMethod(JMethod superMethod, EBeanHolder holder, JBlock callBlock) { - JExpression activitySuper = holder.generatedClass.staticRef("super"); - JInvocation superCall = JExpr.invoke(activitySuper, superMethod); - - for (JVar param : superMethod.params()) { - superCall.arg(param); - } - - JType returnType = superMethod.type(); - if (returnType.fullName().equals("void")) { - callBlock.add(superCall); - } else { - callBlock._return(superCall); - } - } - public JBlock removeBody(JMethod method) { JBlock body = method.body(); try { @@ -332,160 +228,4 @@ public JDefinedClass createDelegatingAnonymousRunnableClass(EComponentHolder hol runCatch.body().add(errorInvoke); return anonymousRunnableClass; } - - public JDefinedClass createDelegatingAnonymousRunnableClass(EBeanHolder holder, JMethod delegatedMethod) { - - JCodeModel codeModel = holder.codeModel(); - Classes classes = holder.classes(); - - JDefinedClass anonymousRunnableClass; - JBlock previousMethodBody = removeBody(delegatedMethod); - - anonymousRunnableClass = codeModel.anonymousClass(Runnable.class); - - JMethod runMethod = anonymousRunnableClass.method(JMod.PUBLIC, codeModel.VOID, "run"); - runMethod.annotate(Override.class); - - JBlock runMethodBody = runMethod.body(); - JTryBlock runTry = runMethodBody._try(); - - runTry.body().add(previousMethodBody); - - JCatchBlock runCatch = runTry._catch(classes.RUNTIME_EXCEPTION); - JVar exceptionParam = runCatch.param("e"); - - JInvocation errorInvoke = classes.LOG.staticInvoke("e"); - - errorInvoke.arg(holder.generatedClass.name()); - errorInvoke.arg("A runtime exception was thrown while executing code in a runnable"); - errorInvoke.arg(exceptionParam); - - runCatch.body().add(errorInvoke); - return anonymousRunnableClass; - } - - public JVar castContextToActivity(EBeanHolder holder, JBlock ifActivityBody) { - JClass activityClass = holder.classes().ACTIVITY; - return ifActivityBody.decl(activityClass, "activity", cast(activityClass, holder.contextRef)); - } - - public JBlock ifContextInstanceOfActivity(EBeanHolder holder, JBlock methodBody) { - return methodBody._if(holder.contextRef._instanceof(holder.classes().ACTIVITY))._then(); - } - - public void copyConstructorsAndAddStaticEViewBuilders(Element element, JCodeModel codeModel, JClass eBeanClass, EBeanHolder holder, JMethod setContentViewMethod, JMethod init) { - List constructors = new ArrayList(); - for (Element e : element.getEnclosedElements()) { - if (e.getKind() == CONSTRUCTOR) { - constructors.add((ExecutableElement) e); - } - } - - for (ExecutableElement userConstructor : constructors) { - JMethod copyConstructor = holder.generatedClass.constructor(PUBLIC); - JMethod staticHelper = holder.generatedClass.method(PUBLIC | STATIC, eBeanClass, "build"); - JBlock body = copyConstructor.body(); - JInvocation superCall = body.invoke("super"); - JInvocation newInvocation = JExpr._new(holder.generatedClass); - for (VariableElement param : userConstructor.getParameters()) { - String paramName = param.getSimpleName().toString(); - String paramType = param.asType().toString(); - copyConstructor.param(holder.refClass(paramType), paramName); - staticHelper.param(holder.refClass(paramType), paramName); - superCall.arg(JExpr.ref(paramName)); - newInvocation.arg(JExpr.ref(paramName)); - } - - JVar newCall = staticHelper.body().decl(holder.generatedClass, "instance", newInvocation); - staticHelper.body().invoke(newCall, "onFinishInflate"); - staticHelper.body()._return(newCall); - body.invoke(init); - } - } - - public JVar findParameterByName(JMethod method, String name) { - for (JVar parameter : method.params()) { - if (parameter.name().equals(name)) { - return parameter; - } - } - return null; - } - - public void addActivityIntentBuilder(JCodeModel codeModel, EBeanHolder holder) throws Exception { - addIntentBuilder(codeModel, holder, true); - } - - public void addServiceIntentBuilder(JCodeModel codeModel, EBeanHolder holder) throws Exception { - addIntentBuilder(codeModel, holder, false); - } - - private void addIntentBuilder(JCodeModel codeModel, EBeanHolder holder, boolean isActivity) throws JClassAlreadyExistsException { - JClass contextClass = holder.classes().CONTEXT; - JClass intentClass = holder.classes().INTENT; - - { - holder.intentBuilderClass = holder.generatedClass._class(PUBLIC | STATIC, "IntentBuilder_"); - - JFieldVar contextField = holder.intentBuilderClass.field(PRIVATE, contextClass, "context_"); - - holder.intentField = holder.intentBuilderClass.field(PRIVATE | FINAL, intentClass, "intent_"); - { - // Constructor - JMethod constructor = holder.intentBuilderClass.constructor(JMod.PUBLIC); - JVar constructorContextParam = constructor.param(contextClass, "context"); - JBlock constructorBody = constructor.body(); - constructorBody.assign(contextField, constructorContextParam); - constructorBody.assign(holder.intentField, _new(intentClass).arg(constructorContextParam).arg(holder.generatedClass.dotclass())); - } - - { - // get() - JMethod method = holder.intentBuilderClass.method(PUBLIC, intentClass, "get"); - method.body()._return(holder.intentField); - } - - { - // flags() - JMethod method = holder.intentBuilderClass.method(PUBLIC, holder.intentBuilderClass, "flags"); - JVar flagsParam = method.param(codeModel.INT, "flags"); - JBlock body = method.body(); - body.invoke(holder.intentField, "setFlags").arg(flagsParam); - body._return(_this()); - } - - if (isActivity) { - // start() - JMethod method = holder.intentBuilderClass.method(PUBLIC, codeModel.VOID, "start"); - method.body().invoke(contextField, "startActivity").arg(holder.intentField); - - // startForResult() - method = holder.intentBuilderClass.method(PUBLIC, codeModel.VOID, "startForResult"); - JVar requestCode = method.param(codeModel.INT, "requestCode"); - - JBlock body = method.body(); - JClass activityClass = holder.classes().ACTIVITY; - JConditional condition = body._if(contextField._instanceof(activityClass)); - condition._then() // - .invoke(JExpr.cast(activityClass, contextField), "startActivityForResult").arg(holder.intentField).arg(requestCode); - condition._else() // - .invoke(contextField, "startActivity").arg(holder.intentField); - } else { - // start() - JMethod method = holder.intentBuilderClass.method(PUBLIC, holder.classes().COMPONENT_NAME, "start"); - method.body()._return(contextField.invoke("startService").arg(holder.intentField)); - - // stop() - method = holder.intentBuilderClass.method(PUBLIC, codeModel.BOOLEAN, "stop"); - method.body()._return(contextField.invoke("stopService").arg(holder.intentField)); - } - - { - // intent() - JMethod method = holder.generatedClass.method(STATIC | PUBLIC, holder.intentBuilderClass, "intent"); - JVar contextParam = method.param(contextClass, "context"); - method.body()._return(_new(holder.intentBuilderClass).arg(contextParam)); - } - } - } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ThirdPartyLibHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ActionBarSherlockHelper.java similarity index 64% rename from AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ThirdPartyLibHelper.java rename to AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ActionBarSherlockHelper.java index 0c409fa271..1adc976fef 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ThirdPartyLibHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ActionBarSherlockHelper.java @@ -16,48 +16,20 @@ package org.androidannotations.helper; import org.androidannotations.holder.EComponentHolder; -import org.androidannotations.processing.EBeanHolder; import javax.lang.model.element.TypeElement; import javax.lang.model.type.DeclaredType; import javax.lang.model.type.NoType; import javax.lang.model.type.TypeMirror; -public class ThirdPartyLibHelper { +public class ActionBarSherlockHelper { private final AnnotationHelper annotationHelper; - public ThirdPartyLibHelper(AnnotationHelper annotationHelper) { + public ActionBarSherlockHelper(AnnotationHelper annotationHelper) { this.annotationHelper = annotationHelper; } - /** - * Checks whether the Activity extends one of the HoloEverywhere Activity - * types - */ - public boolean usesHoloEverywhere(EBeanHolder holder) { - TypeElement typeElement = annotationHelper.typeElementFromQualifiedName(holder.generatedClass._extends().fullName()); - - TypeMirror superType; - while (!((superType = typeElement.getSuperclass()) instanceof NoType)) { - typeElement = (TypeElement) ((DeclaredType) superType).asElement(); - String qName = typeElement.getQualifiedName().toString(); - if (qName.startsWith("org.holoeverywhere")) { - return true; - } - } - return false; - } - - /** - * Checks whether the Activity extends one of the ActionBarSherlock Activity - * types - */ - public boolean usesActionBarSherlock(EBeanHolder holder) { - TypeElement typeElement = annotationHelper.typeElementFromQualifiedName(holder.generatedClass._extends().fullName()); - return usesActionBarSherlock(typeElement); - } - /** * Checks whether the Activity extends one of the ActionBarSherlock Activity * types diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AndroidManifestFinder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AndroidManifestFinder.java index 5db508eeb2..ad20349ec9 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AndroidManifestFinder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AndroidManifestFinder.java @@ -15,14 +15,10 @@ */ package org.androidannotations.helper; -import java.io.File; -import java.io.FileInputStream; -import java.io.IOException; -import java.net.URI; -import java.net.URISyntaxException; -import java.util.ArrayList; -import java.util.List; -import java.util.Properties; +import org.w3c.dom.Document; +import org.w3c.dom.Element; +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; import javax.annotation.processing.Filer; import javax.annotation.processing.Messager; @@ -32,11 +28,14 @@ import javax.tools.JavaFileObject; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; - -import org.w3c.dom.Document; -import org.w3c.dom.Element; -import org.w3c.dom.Node; -import org.w3c.dom.NodeList; +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.net.URI; +import java.net.URISyntaxException; +import java.util.ArrayList; +import java.util.List; +import java.util.Properties; public class AndroidManifestFinder { @@ -213,7 +212,7 @@ private Option parse(File androidManifestFile, boolean libraryP Node debuggableAttribute = applicationNode.getAttributes().getNamedItem("android:debuggable"); if (debuggableAttribute != null) { - applicationDebuggableMode = debuggableAttribute.getNodeValue().equalsIgnoreCase("true") ? true : false; + applicationDebuggableMode = debuggableAttribute.getNodeValue().equalsIgnoreCase("true"); } } @@ -236,7 +235,7 @@ private Option parse(File androidManifestFile, boolean libraryP componentQualifiedNames.addAll(providerQualifiedNames); NodeList usesPermissionNodes = documentElement.getElementsByTagName("uses-permission"); - List usesPermissionQualifiedNames = extractUsesPermissionNames(applicationPackage, usesPermissionNodes); + List usesPermissionQualifiedNames = extractUsesPermissionNames(usesPermissionNodes); List permissionQualifiedNames = new ArrayList(); permissionQualifiedNames.addAll(usesPermissionQualifiedNames); @@ -305,7 +304,7 @@ private String returnClassIfExistsOrNull(String className) { } } - private List extractUsesPermissionNames(String applicationPackage, NodeList usesPermissionNodes) { + private List extractUsesPermissionNames(NodeList usesPermissionNodes) { List usesPermissionQualifiedNames = new ArrayList(); for (int i = 0; i < usesPermissionNodes.getLength(); i++) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AnnotationHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AnnotationHelper.java index 818ecb7bc2..d647aa1352 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AnnotationHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AnnotationHelper.java @@ -15,40 +15,30 @@ */ package org.androidannotations.helper; -import static org.androidannotations.helper.ModelConstants.GENERATION_SUFFIX; -import static org.androidannotations.helper.ModelConstants.VALID_ENHANCED_COMPONENT_ANNOTATIONS; - -import java.lang.annotation.Annotation; -import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Method; -import java.util.ArrayList; -import java.util.List; -import java.util.Map; +import com.sun.codemodel.JFieldRef; +import org.androidannotations.annotations.OnActivityResult; +import org.androidannotations.annotations.OptionsItem; +import org.androidannotations.annotations.ResId; +import org.androidannotations.holder.GeneratedClassHolder; +import org.androidannotations.rclass.IRInnerClass; +import org.androidannotations.rclass.RInnerClass; import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.AnnotationMirror; -import javax.lang.model.element.AnnotationValue; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.Modifier; -import javax.lang.model.element.NestingKind; -import javax.lang.model.element.TypeElement; +import javax.lang.model.element.*; import javax.lang.model.type.DeclaredType; import javax.lang.model.type.MirroredTypeException; import javax.lang.model.type.TypeMirror; import javax.lang.model.util.Elements; import javax.lang.model.util.Types; import javax.tools.Diagnostic; +import java.lang.annotation.Annotation; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; -import org.androidannotations.annotations.OnActivityResult; -import org.androidannotations.annotations.OptionsItem; -import org.androidannotations.annotations.ResId; -import org.androidannotations.holder.GeneratedClassHolder; -import org.androidannotations.processing.EBeanHolder; -import org.androidannotations.rclass.IRInnerClass; -import org.androidannotations.rclass.RInnerClass; - -import com.sun.codemodel.JFieldRef; +import static org.androidannotations.helper.ModelConstants.VALID_ENHANCED_COMPONENT_ANNOTATIONS; public class AnnotationHelper { @@ -155,7 +145,7 @@ public Types getTypeUtils() { * Returns a list of {@link JFieldRef} linking to the R class, based on the * given annotation * - * @see #extractAnnotationResources(Element, Class, IRInnerClass, boolean) + * @see #extractAnnotationResources(Element, String, IRInnerClass, boolean) */ public List extractAnnotationFieldRefs(GeneratedClassHolder holder, Element element, String annotationName, IRInnerClass rInnerClass, boolean useElementName) { List fieldRefs = new ArrayList(); @@ -167,22 +157,6 @@ public List extractAnnotationFieldRefs(GeneratedClassHolder holder, E return fieldRefs; } - /** - * Returns a list of {@link JFieldRef} linking to the R class, based on the - * given annotation - * - * @see #extractAnnotationResources(Element, Class, IRInnerClass, boolean) - */ - public List extractAnnotationFieldRefs(EBeanHolder holder, Element element, String annotationName, IRInnerClass rInnerClass, boolean useElementName) { - List fieldRefs = new ArrayList(); - - for (String refQualifiedName : extractAnnotationResources(element, annotationName, rInnerClass, useElementName)) { - fieldRefs.add(RInnerClass.extractIdStaticRef(holder, refQualifiedName)); - } - - return fieldRefs; - } - /** * Method to handle all annotations dealing with resource ids that can be * set using the value() parameter of the annotation (as int or int[]), the @@ -191,7 +165,7 @@ public List extractAnnotationFieldRefs(EBeanHolder holder, Element el * * @param element * the annotated element - * @param target + * @param annotationName * the annotation on the element * @param rInnerClass * the R innerClass the resources belong to @@ -379,9 +353,7 @@ public DeclaredType extractAnnotationClassParameter(Element element, String anno AnnotationValue annotationValue = entry.getValue(); - DeclaredType annotationClass = (DeclaredType) annotationValue.getValue(); - - return annotationClass; + return (DeclaredType) annotationValue.getValue(); } } @@ -392,14 +364,6 @@ public DeclaredType extractAnnotationClassParameter(Element element, String anno return extractAnnotationClassParameter(element, annotationName, "value"); } - public boolean enclosingElementIsGenerated(Element element) { - /* - * TODO This isn't really safe, can we find a better way? - */ - Element enclosingElement = element.getEnclosingElement(); - return enclosingElement.getSimpleName().toString().endsWith(GENERATION_SUFFIX); - } - public boolean enclosingElementHasEnhancedComponentAnnotation(Element element) { Element enclosingElement = element.getEnclosingElement(); return hasOneOfClassAnnotations(enclosingElement, VALID_ENHANCED_COMPONENT_ANNOTATIONS); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/BundleHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/BundleHelper.java index 3c1252713b..40ca3e397e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/BundleHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/BundleHelper.java @@ -15,23 +15,20 @@ */ package org.androidannotations.helper; -import static org.androidannotations.helper.CanonicalNameConstants.BUNDLE; -import static org.androidannotations.helper.CanonicalNameConstants.CHAR_SEQUENCE; -import static org.androidannotations.helper.CanonicalNameConstants.STRING; - -import java.util.HashMap; -import java.util.List; -import java.util.Map; - import javax.lang.model.element.Element; import javax.lang.model.element.TypeElement; import javax.lang.model.type.ArrayType; import javax.lang.model.type.DeclaredType; import javax.lang.model.type.TypeKind; import javax.lang.model.type.TypeMirror; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.androidannotations.helper.CanonicalNameConstants.*; public class BundleHelper { - private static final Map methodSuffixNameByTypeName = new HashMap(); + public static final Map methodSuffixNameByTypeName = new HashMap(); static { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/GreenDroidConstants.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/GreenDroidConstants.java deleted file mode 100644 index dfa14b5f2b..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/GreenDroidConstants.java +++ /dev/null @@ -1,41 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 java.util.Arrays; -import java.util.List; - -public abstract class GreenDroidConstants { - - public static final String GREENDROID_GD_ACTIVITY_CLASS = "greendroid.app.GDActivity"; - - public static final String GREENDROID_GD_LIST_ACTIVITY_CLASS = "greendroid.app.GDListActivity"; - - public static final String GREENDROID_GD_TAB_ACTIVITY_CLASS = "greendroid.app.GDTabActivity"; - - public static final String GREENDROID_GD_MAP_ACTIVITY_CLASS = "greendroid.app.GDMapActivity"; - - public static final List GREENDROID_ACTIVITIES_LIST_CLASS = Arrays.asList(new String[] { // - GREENDROID_GD_ACTIVITY_CLASS, // - GREENDROID_GD_LIST_ACTIVITY_CLASS, // - GREENDROID_GD_TAB_ACTIVITY_CLASS, // - GREENDROID_GD_MAP_ACTIVITY_CLASS // - }); - - private GreenDroidConstants() { - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/HasTarget.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/HasTarget.java deleted file mode 100644 index 5a98408f00..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/HasTarget.java +++ /dev/null @@ -1,23 +0,0 @@ -/** - * Copyright (C) 2010-2013 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; - - -public interface HasTarget { - - String getTarget(); - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdAnnotationHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdAnnotationHelper.java index a26f4038fc..ec5c70d8e0 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdAnnotationHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdAnnotationHelper.java @@ -17,7 +17,6 @@ import com.sun.codemodel.JFieldRef; import org.androidannotations.holder.GeneratedClassHolder; -import org.androidannotations.processing.EBeanHolder; import org.androidannotations.rclass.IRClass; import org.androidannotations.rclass.IRClass.Res; import org.androidannotations.rclass.IRInnerClass; @@ -53,19 +52,10 @@ public List extractAnnotationFieldRefs(GeneratedClassHolder holder, E return super.extractAnnotationFieldRefs(holder, element, getTarget(), rClass.get(res), useElementName); } - - public List extractAnnotationFieldRefs(EBeanHolder holder, Element element, Res res, boolean useElementName) { - return super.extractAnnotationFieldRefs(holder, element, getTarget(), rClass.get(res), useElementName); - } - public JFieldRef extractOneAnnotationFieldRef(GeneratedClassHolder holder, Element element, Res res, boolean useElementName) { return extractOneAnnotationFieldRef(holder, element, getTarget(), res, useElementName); } - public JFieldRef extractOneAnnotationFieldRef(EBeanHolder holder, Element element, Res res, boolean useElementName) { - return extractOneAnnotationFieldRef(holder, element, getTarget(), res, useElementName); - } - public JFieldRef extractOneAnnotationFieldRef(GeneratedClassHolder holder, Element element, String annotationName, Res res, boolean useElementName) { List jFieldRefs = extractAnnotationFieldRefs(holder, element, annotationName, rClass.get(res), useElementName); @@ -75,16 +65,4 @@ public JFieldRef extractOneAnnotationFieldRef(GeneratedClassHolder holder, Eleme return null; } } - - public JFieldRef extractOneAnnotationFieldRef(EBeanHolder holder, Element element, String annotationName, Res res, boolean useElementName) { - List jFieldRefs = extractAnnotationFieldRefs(holder, element, annotationName, rClass.get(res), useElementName); - - if (jFieldRefs.size() == 1) { - return jFieldRefs.get(0); - } else { - return null; - } - - } - } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdValidatorHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdValidatorHelper.java index 41f74b5780..d1c2ab10cb 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdValidatorHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdValidatorHelper.java @@ -15,15 +15,14 @@ */ package org.androidannotations.helper; -import java.util.List; -import java.util.Set; - -import javax.lang.model.element.Element; - import org.androidannotations.annotations.ResId; import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.IsValid; import org.androidannotations.rclass.IRClass.Res; -import org.androidannotations.validation.IsValid; + +import javax.lang.model.element.Element; +import java.util.List; +import java.util.Set; public class IdValidatorHelper extends ValidatorHelper { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/OnSeekBarChangeListenerHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/OnSeekBarChangeListenerHelper.java deleted file mode 100644 index 50bd246bb5..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/OnSeekBarChangeListenerHelper.java +++ /dev/null @@ -1,101 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 com.sun.codemodel.JExpr.cast; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.type.TypeMirror; - -import org.androidannotations.processing.EBeanHolder; -import org.androidannotations.processing.OnSeekBarChangeListenerHolder; -import org.androidannotations.rclass.IRClass; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JDefinedClass; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JExpression; -import com.sun.codemodel.JFieldRef; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JMod; -import com.sun.codemodel.JVar; - -public class OnSeekBarChangeListenerHelper extends IdAnnotationHelper { - - private final APTCodeModelHelper codeModelHelper; - - public OnSeekBarChangeListenerHelper(// - ProcessingEnvironment processingEnv, // - String annotationName, // - IRClass rClass, // - APTCodeModelHelper codeModelHelper) { - - super(processingEnv, annotationName, rClass); - - this.codeModelHelper = codeModelHelper; - - } - - public OnSeekBarChangeListenerHolder getOrCreateListener(JCodeModel codeModel, EBeanHolder holder, JFieldRef idRef) { - - String idRefString = codeModelHelper.getIdStringFromIdFieldRef(idRef); - OnSeekBarChangeListenerHolder onSeekBarChangeListenerHolder = holder.onSeekBarChangeListeners.get(idRefString); - - if (onSeekBarChangeListenerHolder == null) { - JClass seekBarClass = holder.classes().SEEKBAR; - - JDefinedClass onSeekbarChangeListenerClass = codeModel.anonymousClass(holder.classes().ON_SEEKBAR_CHANGE_LISTENER); - - JMethod onStartTrackingTouchMethod = onSeekbarChangeListenerClass.method(JMod.PUBLIC, codeModel.VOID, "onStartTrackingTouch"); - onStartTrackingTouchMethod.param(seekBarClass, "seekBar"); - onStartTrackingTouchMethod.annotate(Override.class); - - JMethod onProgressChangedMethod = onSeekbarChangeListenerClass.method(JMod.PUBLIC, codeModel.VOID, "onProgressChanged"); - onProgressChangedMethod.param(seekBarClass, "seekBar"); - onProgressChangedMethod.param(codeModel.INT, "progress"); - onProgressChangedMethod.param(codeModel.BOOLEAN, "fromUser"); - onProgressChangedMethod.annotate(Override.class); - - JMethod onStopTrackingTouchMethod = onSeekbarChangeListenerClass.method(JMod.PUBLIC, codeModel.VOID, "onStopTrackingTouch"); - onStopTrackingTouchMethod.param(seekBarClass, "seekBar"); - onStopTrackingTouchMethod.annotate(Override.class); - - JBlock block = holder.onViewChanged().body().block(); - - TypeMirror viewParameterType = typeElementFromQualifiedName(CanonicalNameConstants.SEEKBAR).asType(); - - String viewParameterTypeString = viewParameterType.toString(); - JClass viewClass = holder.refClass(viewParameterTypeString); - - JExpression findViewById = cast(viewClass, holder.onViewChanged().findViewById(idRef)); - - JVar viewVariable = block.decl(JMod.FINAL, viewClass, "view", findViewById); - block._if(viewVariable.ne(JExpr._null()))._then().invoke(viewVariable, "setOnSeekBarChangeListener").arg(JExpr._new(onSeekbarChangeListenerClass)); - - onSeekBarChangeListenerHolder = new OnSeekBarChangeListenerHolder(// - onStartTrackingTouchMethod, // - onProgressChangedMethod, // - onStopTrackingTouchMethod, // - viewVariable); - - holder.onSeekBarChangeListeners.put(idRefString, onSeekBarChangeListenerHolder); - } - - return onSeekBarChangeListenerHolder; - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/RestAnnotationHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/RestAnnotationHelper.java index 17a0c871e0..94b1eb2782 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/RestAnnotationHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/RestAnnotationHelper.java @@ -18,7 +18,7 @@ import com.sun.codemodel.*; import org.androidannotations.annotations.rest.Accept; import org.androidannotations.holder.RestHolder; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/TargetAnnotationHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/TargetAnnotationHelper.java index 1410dbd3a2..3230b213d2 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/TargetAnnotationHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/TargetAnnotationHelper.java @@ -15,13 +15,12 @@ */ package org.androidannotations.helper; -import java.lang.annotation.Annotation; - import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; import javax.lang.model.type.DeclaredType; +import java.lang.annotation.Annotation; -public class TargetAnnotationHelper extends AnnotationHelper implements HasTarget { +public class TargetAnnotationHelper extends AnnotationHelper { private String annotationName; @@ -44,7 +43,6 @@ public DeclaredType extractAnnotationClassParameter(Element element) { return extractAnnotationClassParameter(element, annotationName); } - @Override public String getTarget() { return annotationName; } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/TextWatcherHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/TextWatcherHelper.java deleted file mode 100644 index c02ddac559..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/TextWatcherHelper.java +++ /dev/null @@ -1,110 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 com.sun.codemodel.JExpr._new; -import static com.sun.codemodel.JExpr.cast; -import static com.sun.codemodel.JMod.FINAL; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.type.TypeMirror; - -import org.androidannotations.processing.EBeanHolder; -import org.androidannotations.processing.TextWatcherHolder; -import org.androidannotations.rclass.IRClass; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JDefinedClass; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JExpression; -import com.sun.codemodel.JFieldRef; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JMod; -import com.sun.codemodel.JVar; - -public class TextWatcherHelper extends IdAnnotationHelper { - - private final APTCodeModelHelper codeModelHelper; - - public TextWatcherHelper(// - ProcessingEnvironment processingEnv, // - String annotationName, // - IRClass rClass, // - APTCodeModelHelper codeModelHelper) { - - super(processingEnv, annotationName, rClass); - - this.codeModelHelper = codeModelHelper; - - } - - public TextWatcherHolder getOrCreateListener(JCodeModel codeModel, EBeanHolder holder, JFieldRef idRef, TypeMirror viewParameterType) { - - String idRefString = codeModelHelper.getIdStringFromIdFieldRef(idRef); - TextWatcherHolder textWatcherHolder = holder.textWatchers.get(idRefString); - - if (textWatcherHolder == null) { - JClass charSequenceClass = holder.classes().CHAR_SEQUENCE; - - JDefinedClass onTextChangeListenerClass = codeModel.anonymousClass(holder.classes().TEXT_WATCHER); - - JMethod afterTextChangedMethod = onTextChangeListenerClass.method(JMod.PUBLIC, codeModel.VOID, "afterTextChanged"); - afterTextChangedMethod.param(holder.classes().EDITABLE, "s"); - afterTextChangedMethod.annotate(Override.class); - - JMethod onTextChangedMethod = onTextChangeListenerClass.method(JMod.PUBLIC, codeModel.VOID, "onTextChanged"); - onTextChangedMethod.param(charSequenceClass, "s"); - onTextChangedMethod.param(codeModel.INT, "start"); - onTextChangedMethod.param(codeModel.INT, "before"); - onTextChangedMethod.param(codeModel.INT, "count"); - onTextChangedMethod.annotate(Override.class); - - JMethod beforeTextChangedMethod = onTextChangeListenerClass.method(JMod.PUBLIC, codeModel.VOID, "beforeTextChanged"); - beforeTextChangedMethod.param(charSequenceClass, "s"); - beforeTextChangedMethod.param(codeModel.INT, "start"); - beforeTextChangedMethod.param(codeModel.INT, "count"); - beforeTextChangedMethod.param(codeModel.INT, "after"); - beforeTextChangedMethod.annotate(Override.class); - - JBlock block = holder.onViewChanged().body().block(); - - JClass viewClass; - if (viewParameterType != null) { - String viewParameterTypeString = viewParameterType.toString(); - viewClass = holder.refClass(viewParameterTypeString); - } else { - viewClass = holder.classes().TEXT_VIEW; - } - JExpression findViewById = cast(viewClass, holder.onViewChanged().findViewById(idRef)); - - JVar viewVariable = block.decl(FINAL, viewClass, "view", findViewById); - block._if(viewVariable.ne(JExpr._null()))._then().invoke(viewVariable, "addTextChangedListener").arg(_new(onTextChangeListenerClass)); - - textWatcherHolder = new TextWatcherHolder(// - afterTextChangedMethod, // - beforeTextChangedMethod, // - onTextChangedMethod, // - viewVariable); - - holder.textWatchers.put(idRefString, textWatcherHolder); - } - - return textWatcherHolder; - } - -} 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 259914374f..cba3ec69db 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java @@ -21,8 +21,7 @@ import org.androidannotations.api.sharedpreferences.SharedPreferencesHelper; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.processing.InstanceStateProcessor; -import org.androidannotations.validation.IsValid; +import org.androidannotations.process.IsValid; import javax.lang.model.element.*; import javax.lang.model.type.*; @@ -54,12 +53,12 @@ public class ValidatorHelper { public final ValidatorParameterHelper param; - private final ThirdPartyLibHelper thirdPartyLibHelper; + private final ActionBarSherlockHelper thirdPartyLibHelper; public ValidatorHelper(TargetAnnotationHelper targetAnnotationHelper) { annotationHelper = targetAnnotationHelper; param = new ValidatorParameterHelper(annotationHelper); - thirdPartyLibHelper = new ThirdPartyLibHelper(annotationHelper); + thirdPartyLibHelper = new ActionBarSherlockHelper(annotationHelper); } public void isNotFinal(Element element, IsValid valid) { @@ -104,13 +103,6 @@ public void doesNotReturnPrimitive(ExecutableElement element, IsValid valid) { } } - public void doesNotReturnArray(ExecutableElement element, IsValid valid) { - if (element.getReturnType().getKind() == TypeKind.ARRAY) { - valid.invalidate(); - annotationHelper.printAnnotationError(element, "%s cannot return array"); - } - } - public void isNotPrivate(Element element, IsValid valid) { if (annotationHelper.isPrivate(element)) { valid.invalidate(); @@ -221,23 +213,6 @@ public void hasViewByIdAnnotation(Element element, AnnotationElements validatedE elementHasAnnotation(ViewById.class, element, validatedElements, valid, error); } - public void elementHasRestAnnotationOrEnclosingElementHasRestAnnotationAndElementHasMethodRestAnnotation(Element element, AnnotationElements validatedElements, IsValid valid) { - String error = "can only be used in an interface annotated with"; - elementHasAnnotation(Rest.class, element, validatedElements, valid, error); - - if (!valid.isValid()) { - enclosingElementHasRestAnnotation(element, validatedElements, valid); - elementHasMethodRestAnnotation(element, validatedElements, valid); - } - - } - - public void elementHasMethodRestAnnotation(Element element, AnnotationElements validatedElements, IsValid valid) { - String error = "can only be used on a method annotated with Rest methods."; - elementHasAnnotationContainsIn(REST_ANNOTATION_CLASSES, element, validatedElements, valid, error); - - } - public void enclosingElementHasRestAnnotation(Element element, AnnotationElements validatedElements, IsValid valid) { String error = "can only be used in an interface annotated with"; enclosingElementHasAnnotation(Rest.class, element, validatedElements, valid, error); @@ -260,21 +235,6 @@ public void elementHasAnnotation(Class annotation, Element } } - public void elementHasAnnotationContainsIn(List> annotations, Element element, AnnotationElements validatedElements, IsValid valid, String error) { - boolean isAnnoted = false; - for (Class annotation : annotations) { - if (elementHasAnnotation(annotation, element, validatedElements)) { - isAnnoted = true; - break; - } - } - - if (!isAnnoted) { - valid.invalidate(); - annotationHelper.printAnnotationError(element, "%s " + error); - } - } - public boolean elementHasAnnotation(Class annotation, Element element, AnnotationElements validatedElements) { Set layoutAnnotatedElements = validatedElements.getRootAnnotatedElements(annotation.getName()); return layoutAnnotatedElements.contains(element); @@ -290,13 +250,6 @@ public void throwsOnlyRestClientException(ExecutableElement element, IsValid val } } - public void elementHasGetOrPostAnnotation(Element element, AnnotationElements validatedElements, IsValid valid) { - - if (!elementHasAnnotation(Get.class, element) && !elementHasAnnotation(Post.class, element)) { - annotationHelper.printAnnotationError(element, "%s can only be used in an interface annotated with Get or Post annotation"); - } - } - public void typeHasAnnotation(Class annotation, Element element, IsValid valid) { TypeMirror elementType = element.asType(); typeHasAnnotation(annotation, elementType, element, valid); @@ -335,27 +288,6 @@ private boolean elementHasAnnotationSafe(Class annotation, return false; } - private boolean elementHasAnnotation(Class annotation, Element element) { - return element.getAnnotation(annotation) != null; - } - - public void elementHasRestAnnotation(Element element, AnnotationElements validatedElements, IsValid valid) { - String error = "can only be used in an interface annotated with"; - elementHasAnnotation(Rest.class, element, validatedElements, valid, error); - } - - public void returnTypeNotGenericUnlessResponseEntity(ExecutableElement element, IsValid valid) { - TypeMirror returnType = element.getReturnType(); - TypeKind returnKind = returnType.getKind(); - if (returnKind == TypeKind.DECLARED) { - DeclaredType declaredReturnType = (DeclaredType) returnType; - if (!declaredReturnType.toString().startsWith("org.springframework.http.ResponseEntity<") && declaredReturnType.getTypeArguments().size() > 0) { - valid.invalidate(); - annotationHelper.printAnnotationError(element, "%s annotated methods cannot return parameterized types, except for ResponseEntity"); - } - } - } - public void hasHttpHeadersReturnType(ExecutableElement element, IsValid valid) { String returnType = element.getReturnType().toString(); if (!returnType.equals("org.springframework.http.HttpHeaders")) { @@ -670,13 +602,6 @@ public void isDeclaredType(Element element, IsValid valid) { } } - public void isDeclaredType(Element element, IsValid valid, TypeMirror uiFieldTypeMirror) { - if (!(uiFieldTypeMirror instanceof DeclaredType)) { - valid.invalidate(); - annotationHelper.printAnnotationError(element, "%s can only be used on a field which is a declared type"); - } - } - public void isPrefMethod(Element element, IsValid valid) { if (!element.getKind().equals(ElementKind.METHOD)) { annotationHelper.printError(element, "Only methods are allowed in an " + annotationHelper.annotationName() + " annotated interface"); @@ -959,7 +884,7 @@ private TypeElement getArrayEnclosingType(String typeString) { } private boolean isKnowInstanceStateType(String type) { - return InstanceStateProcessor.methodSuffixNameByTypeName.containsKey(type); + return BundleHelper.methodSuffixNameByTypeName.containsKey(type); } public void componentRegistered(Element element, AndroidManifest androidManifest, IsValid valid) { 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 eadfe16e80..4e65d54e4b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorParameterHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorParameterHelper.java @@ -15,17 +15,16 @@ */ package org.androidannotations.helper; -import static java.util.Arrays.asList; - -import java.util.Arrays; -import java.util.List; +import org.androidannotations.process.IsValid; 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 java.util.Arrays; +import java.util.List; -import org.androidannotations.validation.IsValid; +import static java.util.Arrays.asList; public class ValidatorParameterHelper { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ViewNotifierHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ViewNotifierHelper.java index 4e9e248f86..8535c5c1e4 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ViewNotifierHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ViewNotifierHelper.java @@ -31,14 +31,12 @@ public JVar replacePreviousNotifier(JBlock block) { notifier = holder.getGeneratedClass().field(PRIVATE | FINAL, notifierClass, "onViewChangedNotifier_", _new(notifierClass)); holder.getGeneratedClass()._implements(HasViews.class); } - JVar previousNotifier = block.decl(notifierClass, "previousNotifier", notifierClass.staticInvoke("replaceNotifier").arg(notifier)); - return previousNotifier; + return block.decl(notifierClass, "previousNotifier", notifierClass.staticInvoke("replaceNotifier").arg(notifier)); } public JVar replacePreviousNotifierWithNull(JBlock block) { JClass notifierClass = holder.refClass(OnViewChangedNotifier.class); - JVar previousNotifier = block.decl(notifierClass, "previousNotifier", notifierClass.staticInvoke("replaceNotifier").arg(_null())); - return previousNotifier; + return block.decl(notifierClass, "previousNotifier", notifierClass.staticInvoke("replaceNotifier").arg(_null())); } public void resetPreviousNotifier(JBlock block, JVar previousNotifier) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java index 9723d18c00..c200e343e9 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java @@ -222,7 +222,7 @@ private void setOnOptionsItemSelected() { } private boolean usesActionBarSherlock() { - return new ThirdPartyLibHelper(new AnnotationHelper(processingEnvironment())).usesActionBarSherlock(this); + return new ActionBarSherlockHelper(new AnnotationHelper(processingEnvironment())).usesActionBarSherlock(this); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java index 86945a7c3b..ac413f2994 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java @@ -1,9 +1,9 @@ package org.androidannotations.holder; import com.sun.codemodel.*; +import org.androidannotations.helper.ActionBarSherlockHelper; import org.androidannotations.helper.AnnotationHelper; import org.androidannotations.helper.HoloEverywhereHelper; -import org.androidannotations.helper.ThirdPartyLibHelper; import org.androidannotations.process.ProcessHolder; import javax.lang.model.element.TypeElement; @@ -142,7 +142,7 @@ private void setOnOptionsItemSelected() { } private boolean usesActionBarSherlock() { - return new ThirdPartyLibHelper(new AnnotationHelper(processingEnvironment())).usesActionBarSherlock(this); + return new ActionBarSherlockHelper(new AnnotationHelper(processingEnvironment())).usesActionBarSherlock(this); } @Override 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 5637f24c45..75b2e6fe54 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/AndroidRes.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/AndroidRes.java @@ -18,9 +18,7 @@ import org.androidannotations.annotations.res.*; import org.androidannotations.rclass.IRClass.Res; -import javax.lang.model.element.Element; import java.lang.annotation.Annotation; -import java.lang.reflect.Method; import java.util.Arrays; import java.util.List; @@ -75,15 +73,4 @@ public String getResourceMethodName() { public List getAllowedTypes() { return allowedTypes; } - - public int idFromElement(Element element) { - Annotation annotation = element.getAnnotation(annotationClass); - Method valueMethod = annotationClass.getMethods()[0]; - try { - return (Integer) valueMethod.invoke(annotation); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/AndroidSystemServices.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/AndroidSystemServices.java index 459b438b18..be7fda982b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/AndroidSystemServices.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/AndroidSystemServices.java @@ -17,7 +17,6 @@ import com.sun.codemodel.JFieldRef; import org.androidannotations.holder.EComponentHolder; -import org.androidannotations.processing.EBeanHolder; import javax.lang.model.type.TypeMirror; import java.util.HashMap; @@ -74,11 +73,7 @@ public String getServiceConstant(TypeMirror serviceType) { } public JFieldRef getServiceConstant(TypeMirror serviceType, EComponentHolder holder) { - return extractIdStaticRef(holder, registeredServices.get(serviceType.toString())); - } - - public JFieldRef getServiceConstant(TypeMirror serviceType, EBeanHolder holder) { - return extractIdStaticRef(holder, registeredServices.get(serviceType.toString())); + return extractIdStaticRef(holder, getServiceConstant(serviceType)); } private JFieldRef extractIdStaticRef(EComponentHolder holder, String staticFieldQualifiedName) { @@ -92,17 +87,4 @@ private JFieldRef extractIdStaticRef(EComponentHolder holder, String staticField return null; } } - - private JFieldRef extractIdStaticRef(EBeanHolder holder, String staticFieldQualifiedName) { - if (staticFieldQualifiedName != null) { - int fieldSuffix = staticFieldQualifiedName.lastIndexOf('.'); - String fieldName = staticFieldQualifiedName.substring(fieldSuffix + 1); - String className = staticFieldQualifiedName.substring(0, fieldSuffix); - - return holder.refClass(className).staticRef(fieldName); - } else { - return null; - } - } - } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/ModelExtractor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/ModelExtractor.java index 9449d8b3d2..759e9a70b0 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/ModelExtractor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/ModelExtractor.java @@ -15,10 +15,6 @@ */ package org.androidannotations.model; -import java.util.HashSet; -import java.util.List; -import java.util.Set; - import javax.annotation.processing.RoundEnvironment; import javax.lang.model.element.AnnotationMirror; import javax.lang.model.element.Element; @@ -27,6 +23,9 @@ import javax.lang.model.type.DeclaredType; import javax.lang.model.type.TypeKind; import javax.lang.model.type.TypeMirror; +import java.util.HashSet; +import java.util.List; +import java.util.Set; public class ModelExtractor { @@ -114,18 +113,15 @@ private void extractAnnotations(AnnotationElementsHolder extractedModel, Set elements, TypeElement element) { - if (element instanceof TypeElement) { - TypeElement typeElement = element; - TypeMirror ancestorTypeMirror = typeElement.getSuperclass(); - - if (!isRootObjectClass(ancestorTypeMirror) && ancestorTypeMirror instanceof DeclaredType) { - DeclaredType ancestorDeclaredType = (DeclaredType) ancestorTypeMirror; - Element ancestorElement = ancestorDeclaredType.asElement(); - if (ancestorElement instanceof TypeElement) { - elements.add((TypeElement) ancestorElement); - addAncestorsElements(elements, (TypeElement) ancestorElement); - } + private void addAncestorsElements(Set elements, TypeElement typeElement) { + TypeMirror ancestorTypeMirror = typeElement.getSuperclass(); + + if (!isRootObjectClass(ancestorTypeMirror) && ancestorTypeMirror instanceof DeclaredType) { + DeclaredType ancestorDeclaredType = (DeclaredType) ancestorTypeMirror; + Element ancestorElement = ancestorDeclaredType.asElement(); + if (ancestorElement instanceof TypeElement) { + elements.add((TypeElement) ancestorElement); + addAncestorsElements(elements, (TypeElement) ancestorElement); } } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/IsValid.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/IsValid.java similarity index 94% rename from AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/IsValid.java rename to AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/IsValid.java index 9ca574ff3a..f46d1e0b1c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/IsValid.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/IsValid.java @@ -13,7 +13,7 @@ * License for the specific language governing permissions and limitations under * the License. */ -package org.androidannotations.validation; +package org.androidannotations.process; public class IsValid { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ModelProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ModelProcessor.java index e30a5b8214..9cfb7f4f3b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ModelProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ModelProcessor.java @@ -22,7 +22,6 @@ import org.androidannotations.holder.GeneratedClassHolder; import org.androidannotations.model.AnnotationElements; import org.androidannotations.model.AnnotationElements.AnnotatedAndRootElements; -import org.androidannotations.processing.OriginatingElements; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OriginatingElements.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/OriginatingElements.java similarity index 97% rename from AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OriginatingElements.java rename to AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/OriginatingElements.java index ba2e93b950..5865b56cb9 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OriginatingElements.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/OriginatingElements.java @@ -13,15 +13,14 @@ * License for the specific language governing permissions and limitations under * the License. */ -package org.androidannotations.processing; +package org.androidannotations.process; +import javax.lang.model.element.Element; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; -import javax.lang.model.element.Element; - public class OriginatingElements { private final Map> originatingElementsByClassName = new HashMap>(); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ProcessHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ProcessHolder.java index fbc92db31a..99b4217d30 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ProcessHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ProcessHolder.java @@ -21,7 +21,6 @@ import com.sun.codemodel.JDefinedClass; import org.androidannotations.helper.CanonicalNameConstants; import org.androidannotations.holder.GeneratedClassHolder; -import org.androidannotations.processing.OriginatingElements; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/TimeStats.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/TimeStats.java similarity index 98% rename from AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/TimeStats.java rename to AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/TimeStats.java index e559c04837..e2f067d953 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/TimeStats.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/TimeStats.java @@ -13,7 +13,7 @@ * License for the specific language governing permissions and limitations under * the License. */ -package org.androidannotations.helper; +package org.androidannotations.process; import java.util.ArrayList; import java.util.Collections; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AbstractListenerProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AbstractListenerProcessor.java deleted file mode 100644 index 8e0070fc8c..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AbstractListenerProcessor.java +++ /dev/null @@ -1,106 +0,0 @@ -/** - * Copyright (C) 2010-2013 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; - -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); - - for (JFieldRef idRef : idsRefs) { - ViewChangedHolder onViewChanged = holder.onViewChanged(); - - JBlock block = onViewChanged.body().block(); - JInvocation 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(JInvocation view) { - return view; - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AbstractOptionsMenuProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AbstractOptionsMenuProcessor.java deleted file mode 100644 index fa27a7af29..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AbstractOptionsMenuProcessor.java +++ /dev/null @@ -1,115 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.invoke; -import static com.sun.codemodel.JMod.PUBLIC; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; - -import org.androidannotations.annotations.EFragment; -import org.androidannotations.helper.IdAnnotationHelper; -import org.androidannotations.helper.ThirdPartyLibHelper; -import org.androidannotations.processing.EBeansHolder.Classes; -import org.androidannotations.rclass.IRClass; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JInvocation; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JType; -import com.sun.codemodel.JVar; - -public abstract class AbstractOptionsMenuProcessor implements DecoratingElementProcessor { - - protected final ThirdPartyLibHelper libHelper; - protected final IdAnnotationHelper annotationHelper; - - public AbstractOptionsMenuProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - libHelper = new ThirdPartyLibHelper(annotationHelper); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - if (holder.onCreateOptionMenuMethodBody == null) { - Classes classes = holder.classes(); - - boolean isFragment = holder.eBeanAnnotation == EFragment.class; - - JClass menuClass; - JClass menuInflaterClass; - String getMenuInflaterMethodName; - if (libHelper.usesActionBarSherlock(holder)) { - menuClass = classes.SHERLOCK_MENU; - menuInflaterClass = classes.SHERLOCK_MENU_INFLATER; - getMenuInflaterMethodName = "getSupportMenuInflater"; - } else { - menuClass = classes.MENU; - menuInflaterClass = classes.MENU_INFLATER; - getMenuInflaterMethodName = "getMenuInflater"; - } - - JType returnType; - if (isFragment) { - returnType = codeModel.VOID; - } else { - returnType = codeModel.BOOLEAN; - } - - JBlock body; - JVar menuInflater; - JVar menuParam; - - JMethod method = holder.generatedClass.method(PUBLIC, returnType, "onCreateOptionsMenu"); - method.annotate(Override.class); - - menuParam = method.param(menuClass, "menu"); - - JBlock methodBody = method.body(); - - if (isFragment) { - menuInflater = method.param(menuInflaterClass, "inflater"); - } else { - menuInflater = methodBody.decl(menuInflaterClass, "menuInflater", invoke(getMenuInflaterMethodName)); - } - - body = methodBody.block(); - - JInvocation superCall = invoke(JExpr._super(), method); - superCall.arg(menuParam); - - if (isFragment) { - superCall.arg(menuInflater); - methodBody.add(superCall); - } else { - methodBody._return(superCall); - } - - if (isFragment) { - holder.initBody.invoke("setHasOptionsMenu").arg(JExpr.TRUE); - } - - holder.onCreateOptionMenuMethodBody = body; - holder.onCreateOptionMenuMenuInflaterVariable = menuInflater; - holder.onCreateOptionMenuMenuParam = menuParam; - } - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AbstractTrackingTouchProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AbstractTrackingTouchProcessor.java deleted file mode 100644 index 9868fedb94..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AbstractTrackingTouchProcessor.java +++ /dev/null @@ -1,85 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.Element; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.VariableElement; - -import org.androidannotations.helper.APTCodeModelHelper; -import org.androidannotations.helper.OnSeekBarChangeListenerHelper; -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.JExpression; -import com.sun.codemodel.JFieldRef; -import com.sun.codemodel.JInvocation; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JVar; - -/** - * Note: this could probably be moved to a helper, rather then being an abstract - * class (favor composition over inheritance) - * - */ -public abstract class AbstractTrackingTouchProcessor implements DecoratingElementProcessor { - - private final OnSeekBarChangeListenerHelper helper; - - private final APTCodeModelHelper codeModelHelper; - - public AbstractTrackingTouchProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - codeModelHelper = new APTCodeModelHelper(); - helper = new OnSeekBarChangeListenerHelper(processingEnv, getTarget(), rClass, codeModelHelper); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - - String methodName = element.getSimpleName().toString(); - - List idsRefs = helper.extractAnnotationFieldRefs(holder, element, Res.ID, true); - - for (JFieldRef idRef : idsRefs) { - OnSeekBarChangeListenerHolder onSeekBarChangeListenerHolder = helper.getOrCreateListener(codeModel, holder, idRef); - - JInvocation textChangeCall; - JMethod methodToCall = getMethodToCall(onSeekBarChangeListenerHolder); - - JBlock previousBody = codeModelHelper.removeBody(methodToCall); - JBlock methodBody = methodToCall.body(); - - methodBody.add(previousBody); - JExpression activityRef = holder.generatedClass.staticRef("this"); - textChangeCall = methodBody.invoke(activityRef, methodName); - - ExecutableElement executableElement = (ExecutableElement) element; - List parameters = executableElement.getParameters(); - - if (parameters.size() == 1) { - JVar progressParameter = codeModelHelper.findParameterByName(methodToCall, "seekBar"); - textChangeCall.arg(progressParameter); - } - } - - } - - protected abstract JMethod getMethodToCall(OnSeekBarChangeListenerHolder onSeekBarChangeListenerHolder); -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AfterInjectProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AfterInjectProcessor.java deleted file mode 100644 index 3bba64cf75..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AfterInjectProcessor.java +++ /dev/null @@ -1,38 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 javax.lang.model.element.Element; - -import org.androidannotations.annotations.AfterInject; - -import com.sun.codemodel.JCodeModel; - -public class AfterInjectProcessor implements DecoratingElementProcessor { - - @Override - public String getTarget() { - return AfterInject.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - String methodName = element.getSimpleName().toString(); - - holder.initBody.invoke(methodName); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AfterTextChangeProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AfterTextChangeProcessor.java deleted file mode 100644 index d06698b9f5..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AfterTextChangeProcessor.java +++ /dev/null @@ -1,116 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.Element; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.VariableElement; -import javax.lang.model.type.TypeMirror; - -import org.androidannotations.annotations.AfterTextChange; -import org.androidannotations.helper.APTCodeModelHelper; -import org.androidannotations.helper.CanonicalNameConstants; -import org.androidannotations.helper.TextWatcherHelper; -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.JExpression; -import com.sun.codemodel.JFieldRef; -import com.sun.codemodel.JInvocation; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JVar; - -/** - */ -public class AfterTextChangeProcessor implements DecoratingElementProcessor { - - private final TextWatcherHelper helper; - - private final APTCodeModelHelper codeModelHelper; - - public AfterTextChangeProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - codeModelHelper = new APTCodeModelHelper(); - helper = new TextWatcherHelper(processingEnv, getTarget(), rClass, codeModelHelper); - } - - @Override - public String getTarget() { - return AfterTextChange.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - - String methodName = element.getSimpleName().toString(); - - ExecutableElement executableElement = (ExecutableElement) element; - List parameters = executableElement.getParameters(); - - int editableParameterPosition = -1; - int viewParameterPosition = -1; - TypeMirror viewParameterType = null; - - for (int i = 0; i < parameters.size(); i++) { - VariableElement parameter = parameters.get(i); - TypeMirror parameterType = parameter.asType(); - - if (CanonicalNameConstants.EDITABLE.equals(parameterType.toString())) { - editableParameterPosition = i; - } else { - TypeMirror textViewType = helper.typeElementFromQualifiedName(CanonicalNameConstants.TEXT_VIEW).asType(); - if (helper.isSubtype(parameterType, textViewType)) { - viewParameterPosition = i; - viewParameterType = parameterType; - } - } - - } - - List idsRefs = helper.extractAnnotationFieldRefs(holder, element, Res.ID, true); - - for (JFieldRef idRef : idsRefs) { - TextWatcherHolder textWatcherHolder = helper.getOrCreateListener(codeModel, holder, idRef, viewParameterType); - - JInvocation textChangeCall; - JMethod methodToCall = textWatcherHolder.afterTextChangedMethod; - - JBlock previousBody = codeModelHelper.removeBody(methodToCall); - JBlock methodBody = methodToCall.body(); - - methodBody.add(previousBody); - JExpression activityRef = holder.generatedClass.staticRef("this"); - textChangeCall = methodBody.invoke(activityRef, methodName); - - for (int i = 0; i < parameters.size(); i++) { - if (i == editableParameterPosition) { - JVar afterTextChangeEditableParam = codeModelHelper.findParameterByName(methodToCall, "s"); - textChangeCall.arg(afterTextChangeEditableParam); - } else if (i == viewParameterPosition) { - JVar viewParameter = textWatcherHolder.viewVariable; - textChangeCall.arg(viewParameter); - } - } - - } - - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AfterViewsProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AfterViewsProcessor.java deleted file mode 100644 index 3053f437e3..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AfterViewsProcessor.java +++ /dev/null @@ -1,38 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 javax.lang.model.element.Element; - -import org.androidannotations.annotations.AfterViews; - -import com.sun.codemodel.JCodeModel; - -public class AfterViewsProcessor implements DecoratingElementProcessor { - - @Override - public String getTarget() { - return AfterViews.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - String methodName = element.getSimpleName().toString(); - - holder.onViewChanged().body().invoke(methodName); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AppProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AppProcessor.java deleted file mode 100644 index e4f2198462..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/AppProcessor.java +++ /dev/null @@ -1,47 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.ref; - -import javax.lang.model.element.Element; - -import org.androidannotations.annotations.App; -import org.androidannotations.helper.ModelConstants; - -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; - -public class AppProcessor implements DecoratingElementProcessor { - - @Override - public String getTarget() { - return App.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - - String applicationQualifiedName = element.asType().toString(); - JClass applicationClass = holder.refClass(applicationQualifiedName + ModelConstants.GENERATION_SUFFIX); - - String fieldName = element.getSimpleName().toString(); - - holder.initBody.assign(ref(fieldName), applicationClass.staticInvoke(EApplicationProcessor.GET_APPLICATION_INSTANCE)); - - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/BackgroundProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/BackgroundProcessor.java deleted file mode 100644 index 9db4750e47..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/BackgroundProcessor.java +++ /dev/null @@ -1,74 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.lit; - -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; - -import org.androidannotations.annotations.Background; -import org.androidannotations.api.BackgroundExecutor; -import org.androidannotations.helper.APTCodeModelHelper; - -import com.sun.codemodel.JClass; -import com.sun.codemodel.JClassAlreadyExistsException; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JDefinedClass; -import com.sun.codemodel.JInvocation; -import com.sun.codemodel.JMethod; - -public class BackgroundProcessor implements DecoratingElementProcessor { - - private final APTCodeModelHelper helper = new APTCodeModelHelper(); - - @Override - public String getTarget() { - return Background.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) throws JClassAlreadyExistsException { - - ExecutableElement executableElement = (ExecutableElement) element; - - holder.generateApiClass(element, BackgroundExecutor.class); - - JMethod delegatingMethod = helper.overrideAnnotatedMethod(executableElement, holder); - - JDefinedClass anonymousRunnableClass = helper.createDelegatingAnonymousRunnableClass(holder, delegatingMethod); - - { - // Execute Runnable - Background annotation = element.getAnnotation(Background.class); - long delay = annotation.delay(); - - JClass backgroundExecutorClass = holder.refClass(BackgroundExecutor.class); - JInvocation executeCall; - - if (delay == 0) { - executeCall = backgroundExecutorClass.staticInvoke("execute").arg(_new(anonymousRunnableClass)); - } else { - executeCall = backgroundExecutorClass.staticInvoke("executeDelayed").arg(_new(anonymousRunnableClass)).arg(lit(delay)); - } - - delegatingMethod.body().add(executeCall); - - } - - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/BeanProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/BeanProcessor.java deleted file mode 100644 index c148b0ce77..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/BeanProcessor.java +++ /dev/null @@ -1,86 +0,0 @@ -/** - * Copyright (C) 2010-2013 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._null; -import static com.sun.codemodel.JExpr.ref; -import static org.androidannotations.helper.ModelConstants.GENERATION_SUFFIX; -import static org.androidannotations.processing.EBeanProcessor.GET_INSTANCE_METHOD_NAME; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.type.DeclaredType; -import javax.lang.model.type.TypeMirror; - -import org.androidannotations.annotations.Bean; -import org.androidannotations.annotations.NonConfigurationInstance; -import org.androidannotations.helper.TargetAnnotationHelper; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JFieldRef; -import com.sun.codemodel.JInvocation; - -public class BeanProcessor implements DecoratingElementProcessor { - - private TargetAnnotationHelper annotationHelper; - - public BeanProcessor(ProcessingEnvironment processingEnv) { - annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - } - - @Override - public String getTarget() { - return Bean.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - - DeclaredType targetAnnotationClassValue = annotationHelper.extractAnnotationClassParameter(element); - - TypeMirror elementType; - if (targetAnnotationClassValue != null) { - elementType = targetAnnotationClassValue; - } else { - elementType = element.asType(); - } - - String fieldName = element.getSimpleName().toString(); - - String typeQualifiedName = elementType.toString(); - - JClass injectedClass = holder.refClass(typeQualifiedName + GENERATION_SUFFIX); - - JFieldRef beanField = ref(fieldName); - { - // getInstance - JBlock body = holder.initBody; - - boolean hasNonConfigurationInstanceAnnotation = element.getAnnotation(NonConfigurationInstance.class) != null; - - if (hasNonConfigurationInstanceAnnotation) { - body = body._if(beanField.eq(_null()))._then(); - } - - JInvocation getInstance = injectedClass.staticInvoke(GET_INSTANCE_METHOD_NAME).arg(holder.contextRef); - body.assign(beanField, getInstance); - } - - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/BeforeTextChangeProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/BeforeTextChangeProcessor.java deleted file mode 100644 index 201eb1836b..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/BeforeTextChangeProcessor.java +++ /dev/null @@ -1,136 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.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.BeforeTextChange; -import org.androidannotations.helper.APTCodeModelHelper; -import org.androidannotations.helper.CanonicalNameConstants; -import org.androidannotations.helper.TextWatcherHelper; -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.JExpression; -import com.sun.codemodel.JFieldRef; -import com.sun.codemodel.JInvocation; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JVar; - -/** - */ -public class BeforeTextChangeProcessor implements DecoratingElementProcessor { - - private final TextWatcherHelper helper; - - private final APTCodeModelHelper codeModelHelper; - - public BeforeTextChangeProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - codeModelHelper = new APTCodeModelHelper(); - helper = new TextWatcherHelper(processingEnv, getTarget(), rClass, codeModelHelper); - } - - @Override - public String getTarget() { - return BeforeTextChange.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - - String methodName = element.getSimpleName().toString(); - - ExecutableElement executableElement = (ExecutableElement) element; - List parameters = executableElement.getParameters(); - - int startParameterPosition = -1; - int countParameterPosition = -1; - int afterParameterPosition = -1; - int charSequenceParameterPosition = -1; - int viewParameterPosition = -1; - TypeMirror viewParameterType = null; - - for (int i = 0; i < parameters.size(); i++) { - VariableElement parameter = parameters.get(i); - String parameterName = parameter.toString(); - TypeMirror parameterType = parameter.asType(); - - if (CanonicalNameConstants.CHAR_SEQUENCE.equals(parameterType.toString())) { - charSequenceParameterPosition = i; - } else if (parameterType.getKind() == TypeKind.INT || CanonicalNameConstants.INTEGER.equals(parameterType.toString())) { - if ("start".equals(parameterName)) { - startParameterPosition = i; - } else if ("count".equals(parameterName)) { - countParameterPosition = i; - } else if ("after".equals(parameterName)) { - afterParameterPosition = i; - } - } else { - TypeMirror textViewType = helper.typeElementFromQualifiedName(CanonicalNameConstants.TEXT_VIEW).asType(); - if (helper.isSubtype(parameterType, textViewType)) { - viewParameterPosition = i; - viewParameterType = parameterType; - } - } - - } - - List idsRefs = helper.extractAnnotationFieldRefs(holder, element, Res.ID, true); - - for (JFieldRef idRef : idsRefs) { - TextWatcherHolder textWatcherHolder = helper.getOrCreateListener(codeModel, holder, idRef, viewParameterType); - - JInvocation textChangeCall; - JMethod methodToCall = textWatcherHolder.beforeTextChangedMethod; - - JBlock previousBody = codeModelHelper.removeBody(methodToCall); - JBlock methodBody = methodToCall.body(); - - methodBody.add(previousBody); - JExpression activityRef = holder.generatedClass.staticRef("this"); - textChangeCall = methodBody.invoke(activityRef, methodName); - - for (int i = 0; i < parameters.size(); i++) { - if (i == startParameterPosition) { - JVar startParameter = codeModelHelper.findParameterByName(methodToCall, "start"); - textChangeCall.arg(startParameter); - } else if (i == countParameterPosition) { - JVar countParameter = codeModelHelper.findParameterByName(methodToCall, "count"); - textChangeCall.arg(countParameter); - } else if (i == afterParameterPosition) { - JVar afterParameter = codeModelHelper.findParameterByName(methodToCall, "after"); - textChangeCall.arg(afterParameter); - } else if (i == charSequenceParameterPosition) { - JVar charSequenceParam = codeModelHelper.findParameterByName(methodToCall, "s"); - textChangeCall.arg(charSequenceParam); - } else if (i == viewParameterPosition) { - JVar viewParameter = textWatcherHolder.viewVariable; - textChangeCall.arg(viewParameter); - } - } - } - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/CheckedChangeProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/CheckedChangeProcessor.java deleted file mode 100644 index 0be130f41f..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/CheckedChangeProcessor.java +++ /dev/null @@ -1,87 +0,0 @@ -/** - * Copyright (C) 2010-2013 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; - -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(JInvocation 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 deleted file mode 100644 index ccb829cb44..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ClickProcessor.java +++ /dev/null @@ -1,77 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.Click; -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 ClickProcessor extends AbstractListenerProcessor { - - public ClickProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - super(processingEnv, rClass); - } - - @Override - public String getTarget() { - return Click.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) { - boolean hasItemParameter = parameters.size() == 1; - - JVar viewParam = listenerMethod.param(classes.VIEW, "view"); - - if (hasItemParameter) { - call.arg(viewParam); - } - } - - @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/CustomTitleProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/CustomTitleProcessor.java deleted file mode 100644 index 5bc460a1ae..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/CustomTitleProcessor.java +++ /dev/null @@ -1,51 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; - -import org.androidannotations.annotations.CustomTitle; -import org.androidannotations.helper.AnnotationHelper; -import org.androidannotations.rclass.IRClass; -import org.androidannotations.rclass.IRClass.Res; - -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JFieldRef; - -public class CustomTitleProcessor implements DecoratingElementProcessor { - private final AnnotationHelper annotationHelper; - private final IRClass rClass; - - public CustomTitleProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - annotationHelper = new AnnotationHelper(processingEnv); - this.rClass = rClass; - } - - @Override - public String getTarget() { - return CustomTitle.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - JFieldRef customTitleFeature = holder.classes().WINDOW.staticRef("FEATURE_CUSTOM_TITLE"); - - holder.initBody.invoke("requestWindowFeature").arg(customTitleFeature); - JFieldRef contentViewId = annotationHelper.extractAnnotationFieldRefs(holder, element, getTarget(), rClass.get(Res.LAYOUT), false).get(0); - holder.onViewChanged().body().add(holder.contextRef.invoke("getWindow").invoke("setFeatureInt").arg(customTitleFeature).arg(contentViewId)); - } -} \ No newline at end of file diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/DecoratingElementProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/DecoratingElementProcessor.java deleted file mode 100644 index f2410be6e5..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/DecoratingElementProcessor.java +++ /dev/null @@ -1,31 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 javax.lang.model.element.Element; - -import org.androidannotations.helper.HasTarget; -import com.sun.codemodel.JCodeModel; - -/** - * An enclosed element is either a field or a method. If you come up with a - * better name, please let us know ! - */ -public interface DecoratingElementProcessor extends HasTarget { - - void process(Element element, JCodeModel codeModel, EBeanHolder eBeanHolder) throws Exception; - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EActivityProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EActivityProcessor.java deleted file mode 100644 index 9c8ecb720f..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EActivityProcessor.java +++ /dev/null @@ -1,259 +0,0 @@ -/** - * Copyright (C) 2010-2013 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._super; -import static com.sun.codemodel.JExpr._this; -import static com.sun.codemodel.JMod.FINAL; -import static com.sun.codemodel.JMod.PRIVATE; -import static com.sun.codemodel.JMod.PUBLIC; -import static org.androidannotations.helper.GreenDroidConstants.GREENDROID_ACTIVITIES_LIST_CLASS; - -import java.util.ArrayList; -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.Modifier; -import javax.lang.model.element.TypeElement; -import javax.lang.model.type.TypeKind; -import javax.lang.model.util.ElementFilter; - -import org.androidannotations.annotations.EActivity; -import org.androidannotations.api.SdkVersionHelper; -import org.androidannotations.helper.APTCodeModelHelper; -import org.androidannotations.helper.AnnotationHelper; -import org.androidannotations.helper.CanonicalNameConstants; -import org.androidannotations.helper.ModelConstants; -import org.androidannotations.rclass.IRClass; -import org.androidannotations.rclass.IRClass.Res; - -import com.sun.codemodel.ClassType; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -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.JType; -import com.sun.codemodel.JVar; - -public class EActivityProcessor implements GeneratingElementProcessor { - - private final IRClass rClass; - private List greendroidActivityElements; - - private final AnnotationHelper annotationHelper; - - private final ProcessingEnvironment processingEnv; - private final APTCodeModelHelper aptCodeModelHelper; - - public EActivityProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - this.processingEnv = processingEnv; - annotationHelper = new AnnotationHelper(processingEnv); - aptCodeModelHelper = new APTCodeModelHelper(); - this.rClass = rClass; - - greendroidActivityElements = new ArrayList(); - for (String greendroidActivityName : GREENDROID_ACTIVITIES_LIST_CLASS) { - TypeElement typeElement = annotationHelper.typeElementFromQualifiedName(greendroidActivityName); - if (typeElement != null) { - greendroidActivityElements.add(typeElement); - } - } - } - - @Override - public String getTarget() { - return EActivity.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeansHolder eBeansHolder) throws Exception { - - TypeElement typeElement = (TypeElement) element; - - String annotatedActivityQualifiedName = typeElement.getQualifiedName().toString(); - - String subActivityQualifiedName = annotatedActivityQualifiedName + ModelConstants.GENERATION_SUFFIX; - - JDefinedClass generatedClass = codeModel._class(PUBLIC | FINAL, subActivityQualifiedName, ClassType.CLASS); - - EBeanHolder holder = eBeansHolder.create(element, EActivity.class, generatedClass); - - JClass annotatedActivity = codeModel.directClass(annotatedActivityQualifiedName); - - holder.generatedClass._extends(annotatedActivity); - - holder.contextRef = _this(); - - JClass bundleClass = holder.classes().BUNDLE; - - // beforeSetContentView - JMethod init = holder.generatedClass.method(PRIVATE, codeModel.VOID, "init_"); - holder.initBody = init.body(); - holder.beforeCreateSavedInstanceStateParam = init.param(bundleClass, "savedInstanceState"); - - { - // init if activity - holder.initIfActivityBody = holder.initBody; - holder.initActivityRef = _this(); - } - - // onCreate - JMethod onCreate = holder.generatedClass.method(PUBLIC, codeModel.VOID, "onCreate"); - onCreate.annotate(Override.class); - JVar onCreateSavedInstanceState = onCreate.param(bundleClass, "savedInstanceState"); - - boolean usesGreenDroid = usesGreenDroid(typeElement); - - // onCreateBody - { - JBlock onCreateBody = onCreate.body(); - - JVar previousNotifier = holder.replacePreviousNotifier(onCreateBody); - - onCreateBody.invoke(init).arg(onCreateSavedInstanceState); - - onCreateBody.invoke(_super(), onCreate).arg(onCreateSavedInstanceState); - - holder.resetPreviousNotifier(onCreateBody, previousNotifier); - - List fieldRefs = annotationHelper.extractAnnotationFieldRefs(holder, element, getTarget(), rClass.get(Res.LAYOUT), false); - - JFieldRef contentViewId; - if (fieldRefs.size() == 1) { - contentViewId = fieldRefs.get(0); - } else { - contentViewId = null; - } - - if (contentViewId != null) { - // GreenDroid support - if (usesGreenDroid) { - onCreateBody.invoke("setActionBarContentView").arg(contentViewId); - } else { - onCreateBody.invoke("setContentView").arg(contentViewId); - } - } - } - - // Overriding setContentView (with layout id param) - JClass layoutParamsClass = holder.classes().VIEW_GROUP_LAYOUT_PARAMS; - - String setContentViewMethodName; - if (usesGreenDroid) { - setContentViewMethodName = "setActionBarContentView"; - } else { - setContentViewMethodName = "setContentView"; - } - - setContentViewMethod(setContentViewMethodName, codeModel, holder, new JType[] { codeModel.INT }, new String[] { "layoutResID" }); - setContentViewMethod(setContentViewMethodName, codeModel, holder, new JType[] { holder.classes().VIEW, layoutParamsClass }, new String[] { "view", "params" }); - setContentViewMethod(setContentViewMethodName, codeModel, holder, new JType[] { holder.classes().VIEW }, new String[] { "view" }); - - // Handling onBackPressed - Element declaredOnBackPressedMethod = getOnBackPressedMethod(typeElement); - if (declaredOnBackPressedMethod != null) { - - eBeansHolder.generateApiClass(declaredOnBackPressedMethod, SdkVersionHelper.class); - - JMethod onKeyDownMethod = holder.generatedClass.method(PUBLIC, codeModel.BOOLEAN, "onKeyDown"); - onKeyDownMethod.annotate(Override.class); - JVar keyCodeParam = onKeyDownMethod.param(codeModel.INT, "keyCode"); - JClass keyEventClass = holder.classes().KEY_EVENT; - JVar eventParam = onKeyDownMethod.param(keyEventClass, "event"); - - JClass versionHelperClass = holder.refClass(SdkVersionHelper.class); - - JInvocation sdkInt = versionHelperClass.staticInvoke("getSdkInt"); - - JBlock onKeyDownBody = onKeyDownMethod.body(); - - onKeyDownBody._if( // - sdkInt.lt(JExpr.lit(5)) // - .cand(keyCodeParam.eq(keyEventClass.staticRef("KEYCODE_BACK"))) // - .cand(eventParam.invoke("getRepeatCount").eq(JExpr.lit(0)))) // - ._then() // - .invoke("onBackPressed"); - - onKeyDownBody._return( // - JExpr._super().invoke(onKeyDownMethod) // - .arg(keyCodeParam) // - .arg(eventParam)); - - } - - aptCodeModelHelper.addActivityIntentBuilder(codeModel, holder); - - } - - private void setContentViewMethod(String setContentViewMethodName, JCodeModel codeModel, EBeanHolder holder, JType[] paramTypes, String[] paramNames) { - JMethod method = holder.generatedClass.method(JMod.PUBLIC, codeModel.VOID, setContentViewMethodName); - method.annotate(Override.class); - - ArrayList params = new ArrayList(); - for (int i = 0; i < paramTypes.length; i++) { - JVar param = method.param(paramTypes[i], paramNames[i]); - params.add(param); - } - JBlock body = method.body(); - JInvocation superCall = body.invoke(JExpr._super(), method); - for (JVar arg : params) { - superCall.arg(arg); - } - holder.invokeViewChanged(body); - } - - private ExecutableElement getOnBackPressedMethod(TypeElement activityElement) { - - List allMembers = annotationHelper.getElementUtils().getAllMembers(activityElement); - - List activityInheritedMethods = ElementFilter.methodsIn(allMembers); - - for (ExecutableElement activityInheritedMethod : activityInheritedMethods) { - if (isCustomOnBackPressedMethod(activityInheritedMethod)) { - return activityInheritedMethod; - } - } - return null; - } - - private boolean isCustomOnBackPressedMethod(ExecutableElement method) { - TypeElement methodClass = (TypeElement) method.getEnclosingElement(); - boolean methodBelongsToActivityClass = methodClass.getQualifiedName().toString().equals(CanonicalNameConstants.ACTIVITY); - return !methodBelongsToActivityClass // - && method.getSimpleName().toString().equals("onBackPressed") // - && method.getThrownTypes().size() == 0 // - && method.getModifiers().contains(Modifier.PUBLIC) // - && method.getReturnType().getKind().equals(TypeKind.VOID) // - && method.getParameters().size() == 0 // - ; - } - - private boolean usesGreenDroid(TypeElement typeElement) { - for (TypeElement greendroidActivityElement : greendroidActivityElements) { - if (processingEnv.getTypeUtils().isSubtype(typeElement.asType(), greendroidActivityElement.asType())) { - return true; - } - } - return false; - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EApplicationProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EApplicationProcessor.java deleted file mode 100644 index 33c36bac60..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EApplicationProcessor.java +++ /dev/null @@ -1,104 +0,0 @@ -/** - * Copyright (C) 2010-2013 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._super; -import static com.sun.codemodel.JExpr._this; -import static com.sun.codemodel.JMod.FINAL; -import static com.sun.codemodel.JMod.PRIVATE; -import static com.sun.codemodel.JMod.PUBLIC; -import static com.sun.codemodel.JMod.STATIC; - -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; - -import org.androidannotations.annotations.EApplication; -import org.androidannotations.helper.ModelConstants; - -import com.sun.codemodel.ClassType; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JDefinedClass; -import com.sun.codemodel.JFieldVar; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JMod; -import com.sun.codemodel.JVar; - -public class EApplicationProcessor implements GeneratingElementProcessor { - - public static final String GET_APPLICATION_INSTANCE = "getInstance"; - - @Override - public String getTarget() { - return EApplication.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeansHolder eBeansHolder) throws Exception { - - TypeElement typeElement = (TypeElement) element; - - String annotatedComponentQualifiedName = typeElement.getQualifiedName().toString(); - - String generatedComponentQualifiedName = annotatedComponentQualifiedName + ModelConstants.GENERATION_SUFFIX; - - JDefinedClass generatedClass = codeModel._class(PUBLIC | FINAL, generatedComponentQualifiedName, ClassType.CLASS); - EBeanHolder holder = eBeansHolder.create(element, EApplication.class, generatedClass); - - JClass annotatedComponent = codeModel.directClass(annotatedComponentQualifiedName); - - holder.generatedClass._extends(annotatedComponent); - - holder.contextRef = _this(); - - JFieldVar staticInstanceField = holder.generatedClass.field(PRIVATE | STATIC, annotatedComponent, "INSTANCE_"); - { - // Static singleton getter and setter - JMethod getInstance = holder.generatedClass.method(PUBLIC | JMod.STATIC, annotatedComponent, GET_APPLICATION_INSTANCE); - getInstance.body()._return(staticInstanceField); - - JMethod setInstance = holder.generatedClass.method(PUBLIC | JMod.STATIC, codeModel.VOID, "setForTesting"); - setInstance.javadoc().append("Visible for testing purposes"); - JVar applicationParam = setInstance.param(annotatedComponent, "application"); - setInstance.body().assign(staticInstanceField, applicationParam); - } - - JMethod init = holder.generatedClass.method(PRIVATE, codeModel.VOID, "init_"); - holder.initBody = init.body(); - { - // onCreate - JMethod onCreate = holder.generatedClass.method(PUBLIC, codeModel.VOID, "onCreate"); - onCreate.annotate(Override.class); - JBlock onCreateBody = onCreate.body(); - onCreateBody.assign(staticInstanceField, _this()); - onCreateBody.invoke(init); - onCreateBody.invoke(_super(), onCreate); - } - - { - /* - * Setting to null shouldn't be a problem as long as we do not allow - * - * @Extra on this component - */ - holder.initIfActivityBody = null; - holder.initActivityRef = null; - } - - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EBeanHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EBeanHolder.java deleted file mode 100644 index cf1792c191..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EBeanHolder.java +++ /dev/null @@ -1,217 +0,0 @@ -/** - * Copyright (C) 2010-2013 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._this; -import static com.sun.codemodel.JMod.FINAL; -import static com.sun.codemodel.JMod.PRIVATE; -import static com.sun.codemodel.JMod.PUBLIC; - -import java.lang.annotation.Annotation; -import java.util.HashMap; - -import javax.lang.model.element.Element; - -import org.androidannotations.api.view.HasViews; -import org.androidannotations.api.view.OnViewChangedListener; -import org.androidannotations.api.view.OnViewChangedNotifier; -import org.androidannotations.processing.EBeansHolder.Classes; - -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.JFieldVar; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JSwitch; -import com.sun.codemodel.JVar; - -public class EBeanHolder { - - public final JDefinedClass generatedClass; - /** - * Only defined on activities - */ - public JVar beforeCreateSavedInstanceStateParam; - public JBlock initBody; - - public JBlock extrasNotNullBlock; - public JVar extras; - public JVar resources; - - public JMethod cast; - - public JFieldVar handler; - - public JBlock onOptionsItemSelectedIfElseBlock; - public JVar onOptionsItemSelectedItemId; - public JVar onOptionsItemSelectedItem; - - public JMethod restoreSavedInstanceStateMethod; - public JBlock saveInstanceStateBlock; - - public JBlock onResumeBlock; - public JBlock onDestroyBlock; - - public JExpression contextRef; - /** - * Should not be used by inner annotations that target services, broadcast - * receivers, and content providers - */ - public JBlock initIfActivityBody; - public JExpression initActivityRef; - - /** - * Only defined in activities - */ - public JDefinedClass intentBuilderClass; - - /** - * Only defined in activities - */ - public JFieldVar intentField; - - /** - * Only defined in activities - */ - public NonConfigurationHolder nonConfigurationHolder; - - /** - * TextWatchers by idRef - */ - public final HashMap textWatchers = new HashMap(); - - /** - * OnActivityResult byResultCode - */ - public final HashMap onActivityResultCases = new HashMap(); - - public JSwitch onActivityResultSwitch; - public JMethod onActivityResultMethod; - - /** - * onSeekBarChangeListeners by idRef - */ - public final HashMap onSeekBarChangeListeners = new HashMap(); - - public JVar fragmentArguments; - public JFieldVar fragmentArgumentsBuilderField; - public JMethod fragmentArgumentsInjectMethod; - public JBlock fragmentArgumentsNotNullBlock; - public JDefinedClass fragmentBuilderClass; - - public JMethod findNativeFragmentById; - public JMethod findSupportFragmentById; - public JMethod findNativeFragmentByTag; - public JMethod findSupportFragmentByTag; - - public JBlock onCreateOptionMenuMethodBody; - public JVar onCreateOptionMenuMenuInflaterVariable; - public JVar onCreateOptionMenuMenuParam; - - private final EBeansHolder eBeansHolder; - public final Class eBeanAnnotation; - - private ViewChangedHolder viewChangedHolder; - - /** - * Only defined in beans that implement {@link HasViews} - */ - private JExpression notifier; - - public EBeanHolder(EBeansHolder eBeansHolder, Class eBeanAnnotation, JDefinedClass generatedClass) { - this.eBeansHolder = eBeansHolder; - this.eBeanAnnotation = eBeanAnnotation; - this.generatedClass = generatedClass; - } - - public Classes classes() { - return eBeansHolder.classes(); - } - - public JCodeModel codeModel() { - return eBeansHolder.codeModel(); - } - - public JClass refClass(String fullyQualifiedClassName) { - return eBeansHolder.refClass(fullyQualifiedClassName); - } - - public JClass refClass(Class clazz) { - return eBeansHolder.refClass(clazz); - } - - public JDefinedClass definedClass(String fullyQualifiedClassName) { - return eBeansHolder.definedClass(fullyQualifiedClassName); - } - - public void generateApiClass(Element originatingElement, Class apiClass) { - eBeansHolder.generateApiClass(originatingElement, apiClass); - } - - public ViewChangedHolder onViewChanged() { - - if (viewChangedHolder == null) { - JCodeModel codeModel = eBeansHolder.codeModel(); - - generatedClass._implements(OnViewChangedListener.class); - JMethod onViewChanged = generatedClass.method(PUBLIC, codeModel.VOID, "onViewChanged"); - onViewChanged.annotate(Override.class); - JVar onViewChangedHasViewsParam = onViewChanged.param(HasViews.class, "hasViews"); - JClass notifierClass = refClass(OnViewChangedNotifier.class); - initBody.staticInvoke(notifierClass, "registerOnViewChangedListener").arg(_this()); - - viewChangedHolder = new ViewChangedHolder(onViewChanged, onViewChangedHasViewsParam); - } - return viewChangedHolder; - } - - public void invokeViewChanged(JBlock block) { - block.invoke(notifier, "notifyViewChanged").arg(_this()); - } - - public JVar replacePreviousNotifier(JBlock block) { - JClass notifierClass = refClass(OnViewChangedNotifier.class); - if (notifier == null) { - notifier = generatedClass.field(PRIVATE | FINAL, notifierClass, "onViewChangedNotifier_", _new(notifierClass)); - generatedClass._implements(HasViews.class); - } - JVar previousNotifier = block.decl(notifierClass, "previousNotifier", notifierClass.staticInvoke("replaceNotifier").arg(notifier)); - return previousNotifier; - } - - public JVar replacePreviousNotifierWithNull(JBlock block) { - JClass notifierClass = refClass(OnViewChangedNotifier.class); - JVar previousNotifier = block.decl(notifierClass, "previousNotifier", notifierClass.staticInvoke("replaceNotifier").arg(_null())); - return previousNotifier; - } - - public void resetPreviousNotifier(JBlock block, JVar previousNotifier) { - JClass notifierClass = refClass(OnViewChangedNotifier.class); - block.staticInvoke(notifierClass, "replaceNotifier").arg(previousNotifier); - } - - public void wrapInitWithNotifier() { - JBlock initBlock = initBody; - JVar previousNotifier = replacePreviousNotifier(initBlock); - initBody = initBody.block(); - resetPreviousNotifier(initBlock, previousNotifier); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EBeanProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EBeanProcessor.java deleted file mode 100644 index 899a24500b..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EBeanProcessor.java +++ /dev/null @@ -1,169 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.JMod.FINAL; -import static com.sun.codemodel.JMod.PRIVATE; -import static com.sun.codemodel.JMod.PUBLIC; -import static com.sun.codemodel.JMod.STATIC; -import static org.androidannotations.helper.ModelConstants.GENERATION_SUFFIX; - -import java.util.List; - -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.TypeElement; -import javax.lang.model.util.ElementFilter; - -import org.androidannotations.annotations.EBean; -import org.androidannotations.helper.APTCodeModelHelper; -import org.androidannotations.processing.EBeansHolder.Classes; - -import com.sun.codemodel.ClassType; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JDefinedClass; -import com.sun.codemodel.JFieldVar; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JVar; - -public class EBeanProcessor implements GeneratingElementProcessor { - - public static final String GET_INSTANCE_METHOD_NAME = "getInstance" + GENERATION_SUFFIX; - - @Override - public String getTarget() { - return EBean.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeansHolder eBeansHolder) throws Exception { - - TypeElement typeElement = (TypeElement) element; - - String eBeanQualifiedName = typeElement.getQualifiedName().toString(); - - String generatedBeanQualifiedName = eBeanQualifiedName + GENERATION_SUFFIX; - - JDefinedClass generatedClass = codeModel._class(PUBLIC | FINAL, generatedBeanQualifiedName, ClassType.CLASS); - - EBeanHolder holder = eBeansHolder.create(element, EBean.class, generatedClass); - - JClass eBeanClass = codeModel.directClass(eBeanQualifiedName); - - holder.generatedClass._extends(eBeanClass); - - Classes classes = holder.classes(); - - JFieldVar contextField = holder.generatedClass.field(PRIVATE, classes.CONTEXT, "context_"); - - holder.contextRef = contextField; - - JMethod init; - { - // init - init = holder.generatedClass.method(PRIVATE, codeModel.VOID, "init_"); - holder.initBody = init.body(); - } - - { - // init if activity - /* - * We suppress all warnings because we generate an unused warning - * that may or may not valid - */ - init.annotate(SuppressWarnings.class).param("value", "all"); - APTCodeModelHelper helper = new APTCodeModelHelper(); - holder.initIfActivityBody = helper.ifContextInstanceOfActivity(holder, holder.initBody); - holder.initActivityRef = helper.castContextToActivity(holder, holder.initIfActivityBody); - } - - { - // Constructor - - JMethod constructor = holder.generatedClass.constructor(PRIVATE); - - JVar constructorContextParam = constructor.param(classes.CONTEXT, "context"); - - JBlock constructorBody = constructor.body(); - - List constructors = ElementFilter.constructorsIn(element.getEnclosedElements()); - - ExecutableElement superConstructor = constructors.get(0); - - if (superConstructor.getParameters().size() == 1) { - constructorBody.invoke("super").arg(constructorContextParam); - } - - constructorBody.assign(contextField, constructorContextParam); - - constructorBody.invoke(init); - } - - EBean eBeanAnnotation = element.getAnnotation(EBean.class); - EBean.Scope eBeanScope = eBeanAnnotation.scope(); - boolean hasSingletonScope = eBeanScope == EBean.Scope.Singleton; - - { - // Factory method - - JMethod factoryMethod = holder.generatedClass.method(PUBLIC | STATIC, holder.generatedClass, GET_INSTANCE_METHOD_NAME); - - JVar factoryMethodContextParam = factoryMethod.param(classes.CONTEXT, "context"); - - JBlock factoryMethodBody = factoryMethod.body(); - - /* - * Singletons are bound to the application context - */ - if (hasSingletonScope) { - - JFieldVar instanceField = holder.generatedClass.field(PRIVATE | STATIC, holder.generatedClass, "instance_"); - - JBlock creationBlock = factoryMethodBody // - ._if(instanceField.eq(_null())) // - ._then(); - JVar previousNotifier = holder.replacePreviousNotifierWithNull(creationBlock); - creationBlock.assign(instanceField, _new(holder.generatedClass).arg(factoryMethodContextParam.invoke("getApplicationContext"))); - holder.resetPreviousNotifier(creationBlock, previousNotifier); - - factoryMethodBody._return(instanceField); - } else { - factoryMethodBody._return(_new(holder.generatedClass).arg(factoryMethodContextParam)); - } - } - - { - // rebind(Context) - JMethod rebindMethod = holder.generatedClass.method(PUBLIC, codeModel.VOID, "rebind"); - JVar contextParam = rebindMethod.param(classes.CONTEXT, "context"); - - /* - * No rebinding of context for singletons, their are bound to the - * application context - */ - if (!hasSingletonScope) { - JBlock body = rebindMethod.body(); - body.assign(contextField, contextParam); - body.invoke(init); - } - } - - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EBeansHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EBeansHolder.java deleted file mode 100644 index bfc5e4137c..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EBeansHolder.java +++ /dev/null @@ -1,252 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.io.FileInputStream; -import java.io.InputStream; -import java.io.Serializable; -import java.lang.annotation.Annotation; -import java.sql.SQLException; -import java.util.HashMap; -import java.util.HashSet; -import java.util.Map; -import java.util.Set; - -import javax.lang.model.element.Element; - -import org.androidannotations.helper.CanonicalNameConstants; - -import com.sun.codemodel.JClass; -import com.sun.codemodel.JClassAlreadyExistsException; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JDefinedClass; - -public class EBeansHolder { - - public class Classes { - - /* - * Java - */ - public final JClass RUNTIME_EXCEPTION = refClass(RuntimeException.class); - public final JClass EXCEPTION = refClass(Exception.class); - public final JClass CHAR_SEQUENCE = refClass(CharSequence.class); - public final JClass CLASS_CAST_EXCEPTION = refClass(ClassCastException.class); - public final JClass SERIALIZABLE = refClass(Serializable.class); - public final JClass STRING = refClass(String.class); - public final JClass SYSTEM = refClass(System.class); - public final JClass INPUT_STREAM = refClass(InputStream.class); - public final JClass FILE_INPUT_STREAM = refClass(FileInputStream.class); - public final JClass SQL_EXCEPTION = refClass(SQLException.class); - - /* - * Android - */ - public final JClass LOG = refClass(CanonicalNameConstants.LOG); - public final JClass BUNDLE = refClass(CanonicalNameConstants.BUNDLE); - public final JClass ACTIVITY = refClass(CanonicalNameConstants.ACTIVITY); - public final JClass EDITABLE = refClass(CanonicalNameConstants.EDITABLE); - public final JClass TEXT_WATCHER = refClass(CanonicalNameConstants.TEXT_WATCHER); - 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); - public final JClass INTENT = refClass(CanonicalNameConstants.INTENT); - public final JClass COMPONENT_NAME = refClass(CanonicalNameConstants.COMPONENT_NAME); - public final JClass VIEW_GROUP = refClass(CanonicalNameConstants.VIEW_GROUP); - public final JClass LAYOUT_INFLATER = refClass(CanonicalNameConstants.LAYOUT_INFLATER); - public final JClass FRAGMENT_ACTIVITY = refClass(CanonicalNameConstants.FRAGMENT_ACTIVITY); - public final JClass FRAGMENT = refClass(CanonicalNameConstants.FRAGMENT); - public final JClass SUPPORT_V4_FRAGMENT = refClass(CanonicalNameConstants.SUPPORT_V4_FRAGMENT); - public final JClass HTML = refClass(CanonicalNameConstants.HTML); - public final JClass WINDOW_MANAGER_LAYOUT_PARAMS = refClass(CanonicalNameConstants.WINDOW_MANAGER_LAYOUT_PARAMS); - public final JClass ADAPTER_VIEW = refClass(CanonicalNameConstants.ADAPTER_VIEW); - 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 WINDOW = refClass(CanonicalNameConstants.WINDOW); - public final JClass MENU_ITEM = refClass(CanonicalNameConstants.MENU_ITEM); - public final JClass MENU_INFLATER = refClass(CanonicalNameConstants.MENU_INFLATER); - public final JClass MENU = refClass(CanonicalNameConstants.MENU); - public final JClass ANIMATION_UTILS = refClass(CanonicalNameConstants.ANIMATION_UTILS); - 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 HANDLER = refClass(CanonicalNameConstants.HANDLER); - public final JClass KEY_STORE = refClass(CanonicalNameConstants.KEY_STORE); - public final JClass VIEW_SERVER = refClass(CanonicalNameConstants.VIEW_SERVER); - public final JClass PARCELABLE = refClass(CanonicalNameConstants.PARCELABLE); - - /* - * Sherlock - */ - public final JClass SHERLOCK_MENU = refClass(CanonicalNameConstants.SHERLOCK_MENU); - public final JClass SHERLOCK_MENU_ITEM = refClass(CanonicalNameConstants.SHERLOCK_MENU_ITEM); - public final JClass SHERLOCK_MENU_INFLATER = refClass(CanonicalNameConstants.SHERLOCK_MENU_INFLATER); - - /* - * HoloEverywhre - */ - public final JClass HOLO_EVERYWHERE_LAYOUT_INFLATER = refClass(CanonicalNameConstants.HOLO_EVERYWHERE_LAYOUT_INFLATER); - - /* - * RoboGuice - */ - public final JClass INJECTOR_PROVIDER = refClass(CanonicalNameConstants.INJECTOR_PROVIDER); - public final JClass INJECTOR = refClass(CanonicalNameConstants.INJECTOR); - public final JClass ON_RESTART_EVENT = refClass(CanonicalNameConstants.ON_RESTART_EVENT); - public final JClass ON_START_EVENT = refClass(CanonicalNameConstants.ON_START_EVENT); - public final JClass ON_RESUME_EVENT = refClass(CanonicalNameConstants.ON_RESUME_EVENT); - public final JClass ON_PAUSE_EVENT = refClass(CanonicalNameConstants.ON_PAUSE_EVENT); - public final JClass ON_NEW_INTENT_EVENT = refClass(CanonicalNameConstants.ON_NEW_INTENT_EVENT); - public final JClass EVENT_MANAGER = refClass(CanonicalNameConstants.EVENT_MANAGER); - public final JClass CONTEXT_SCOPE = refClass(CanonicalNameConstants.CONTEXT_SCOPE); - public final JClass INJECT = refClass(CanonicalNameConstants.INJECT); - public final JClass ON_STOP_EVENT = refClass(CanonicalNameConstants.ON_STOP_EVENT); - public final JClass ON_DESTROY_EVENT = refClass(CanonicalNameConstants.ON_DESTROY_EVENT); - public final JClass ON_CONFIGURATION_CHANGED_EVENT = refClass(CanonicalNameConstants.ON_CONFIGURATION_CHANGED_EVENT); - public final JClass ON_CONTENT_CHANGED_EVENT = refClass(CanonicalNameConstants.ON_CONTENT_CHANGED_EVENT); - public final JClass ON_ACTIVITY_RESULT_EVENT = refClass(CanonicalNameConstants.ON_ACTIVITY_RESULT_EVENT); - public final JClass ON_CONTENT_VIEW_AVAILABLE_EVENT = refClass(CanonicalNameConstants.ON_CONTENT_VIEW_AVAILABLE_EVENT); - public final JClass ON_CREATE_EVENT = refClass(CanonicalNameConstants.ON_CREATE_EVENT); - - /* - * OrmLite - */ - public final JClass CONNECTION_SOURCE = refClass(CanonicalNameConstants.CONNECTION_SOURCE); - public final JClass OPEN_HELPER_MANAGER = refClass(CanonicalNameConstants.OPEN_HELPER_MANAGER); - public final JClass DAO_MANAGER = refClass(CanonicalNameConstants.DAO_MANAGER); - - /* - * HttpClient - */ - public final JClass CLIENT_CONNECTION_MANAGER = refClass(CanonicalNameConstants.CLIENT_CONNECTION_MANAGER); - public final JClass DEFAULT_HTTP_CLIENT = refClass(CanonicalNameConstants.DEFAULT_HTTP_CLIENT); - public final JClass SSL_SOCKET_FACTORY = refClass(CanonicalNameConstants.SSL_SOCKET_FACTORY); - public final JClass SCHEME = refClass(CanonicalNameConstants.SCHEME); - public final JClass SCHEME_REGISTRY = refClass(CanonicalNameConstants.SCHEME_REGISTRY); - public final JClass SINGLE_CLIENT_CONN_MANAGER = refClass(CanonicalNameConstants.SINGLE_CLIENT_CONN_MANAGER); - - } - - private final Map eBeanHolders = new HashMap(); - - private final JCodeModel codeModel; - - private final Map loadedClasses = new HashMap(); - - private final Classes classes; - - private final Set> apiClassesToGenerate = new HashSet>(); - - private final OriginatingElements originatingElements = new OriginatingElements(); - - public EBeansHolder(JCodeModel codeModel) { - this.codeModel = codeModel; - classes = new Classes(); - refClass(CanonicalNameConstants.STRING); - preloadJavaLangClasses(); - } - - private void preloadJavaLangClasses() { - loadedClasses.put(String.class.getName(), refClass(String.class)); - loadedClasses.put(Object.class.getName(), refClass(Object.class)); - } - - public EBeanHolder create(Element element, Class eBeanAnnotation, JDefinedClass generatedClass) { - - String qualifiedName = generatedClass.fullName(); - - originatingElements.add(qualifiedName, element); - - EBeanHolder activityHolder = new EBeanHolder(this, eBeanAnnotation, generatedClass); - eBeanHolders.put(element, activityHolder); - return activityHolder; - } - - public EBeanHolder getEBeanHolder(Element element) { - return eBeanHolders.get(element); - } - - public JClass refClass(Class clazz) { - return codeModel.ref(clazz); - } - - public JClass refClass(String fullyQualifiedClassName) { - - int arrayCounter = 0; - while (fullyQualifiedClassName.endsWith("[]")) { - arrayCounter++; - fullyQualifiedClassName = fullyQualifiedClassName.substring(0, fullyQualifiedClassName.length() - 2); - } - - JClass refClass = loadedClasses.get(fullyQualifiedClassName); - - if (refClass == null) { - refClass = codeModel.directClass(fullyQualifiedClassName); - loadedClasses.put(fullyQualifiedClassName, refClass); - } - - for (int i = 0; i < arrayCounter; i++) { - refClass = refClass.array(); - } - - return refClass; - } - - public JDefinedClass definedClass(String fullyQualifiedClassName) { - JDefinedClass refClass = (JDefinedClass) loadedClasses.get(fullyQualifiedClassName); - if (refClass == null) { - try { - refClass = codeModel._class(fullyQualifiedClassName); - } catch (JClassAlreadyExistsException e) { - refClass = (JDefinedClass) refClass(fullyQualifiedClassName); - } - loadedClasses.put(fullyQualifiedClassName, refClass); - } - return refClass; - } - - public JCodeModel codeModel() { - return codeModel; - } - - public Classes classes() { - return classes; - } - - public OriginatingElements getOriginatingElements() { - return originatingElements; - } - - public Set> getApiClassesToGenerate() { - return apiClassesToGenerate; - } - - public void generateApiClass(Element originatingElement, Class apiClass) { - originatingElements.add(apiClass.getCanonicalName(), originatingElement); - apiClassesToGenerate.add(apiClass); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EFragmentProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EFragmentProcessor.java deleted file mode 100644 index a6053c380e..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EFragmentProcessor.java +++ /dev/null @@ -1,216 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.FALSE; -import static com.sun.codemodel.JExpr._new; -import static com.sun.codemodel.JExpr._null; -import static com.sun.codemodel.JExpr._super; -import static com.sun.codemodel.JExpr.invoke; -import static com.sun.codemodel.JMod.FINAL; -import static com.sun.codemodel.JMod.PRIVATE; -import static com.sun.codemodel.JMod.PUBLIC; -import static com.sun.codemodel.JMod.STATIC; -import static org.androidannotations.helper.ModelConstants.GENERATION_SUFFIX; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; - -import org.androidannotations.annotations.EFragment; -import org.androidannotations.helper.IdAnnotationHelper; -import org.androidannotations.helper.ThirdPartyLibHelper; -import org.androidannotations.processing.EBeansHolder.Classes; -import org.androidannotations.rclass.IRClass; -import org.androidannotations.rclass.IRClass.Res; - -import com.sun.codemodel.ClassType; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JClassAlreadyExistsException; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JDefinedClass; -import com.sun.codemodel.JFieldRef; -import com.sun.codemodel.JFieldVar; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JVar; - -public class EFragmentProcessor implements GeneratingElementProcessor { - - private final IdAnnotationHelper helper; - private ThirdPartyLibHelper holoEverywhereHelper; - - public EFragmentProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - helper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - holoEverywhereHelper = new ThirdPartyLibHelper(helper); - - } - - @Override - public String getTarget() { - return EFragment.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeansHolder eBeansHolder) throws Exception { - - TypeElement typeElement = (TypeElement) element; - - String beanQualifiedName = typeElement.getQualifiedName().toString(); - - String generatedBeanQualifiedName = beanQualifiedName + GENERATION_SUFFIX; - - JDefinedClass generatedClass = codeModel._class(PUBLIC | FINAL, generatedBeanQualifiedName, ClassType.CLASS); - - EBeanHolder holder = eBeansHolder.create(element, EFragment.class, generatedClass); - - JClass eBeanClass = codeModel.directClass(beanQualifiedName); - - holder.generatedClass._extends(eBeanClass); - - Classes classes = holder.classes(); - - JMethod init; - { - // init - init = holder.generatedClass.method(PRIVATE, codeModel.VOID, "init_"); - init.param(holder.classes().BUNDLE, "savedInstanceState"); - holder.initBody = init.body(); - } - - { - // onCreate() - - JMethod onCreate = holder.generatedClass.method(PUBLIC, codeModel.VOID, "onCreate"); - onCreate.annotate(Override.class); - JVar onCreateSavedInstanceState = onCreate.param(classes.BUNDLE, "savedInstanceState"); - JBlock onCreateBody = onCreate.body(); - - JVar previousNotifier = holder.replacePreviousNotifier(onCreateBody); - - onCreateBody.invoke(init).arg(onCreateSavedInstanceState); - - onCreateBody.invoke(_super(), onCreate).arg(onCreateSavedInstanceState); - - holder.resetPreviousNotifier(onCreateBody, previousNotifier); - } - - holder.contextRef = invoke("getActivity"); - - // contentView - JFieldVar contentView = holder.generatedClass.field(PRIVATE, classes.VIEW, "contentView_"); - - { - // onCreateView() - JMethod onCreateView = holder.generatedClass.method(PUBLIC, classes.VIEW, "onCreateView"); - onCreateView.annotate(Override.class); - - JClass inflaterClass; - if (holoEverywhereHelper.usesHoloEverywhere(holder)) { - inflaterClass = classes.HOLO_EVERYWHERE_LAYOUT_INFLATER; - } else { - inflaterClass = classes.LAYOUT_INFLATER; - } - - JVar inflater = onCreateView.param(inflaterClass, "inflater"); - - JVar container = onCreateView.param(classes.VIEW_GROUP, "container"); - JVar savedInstanceState = onCreateView.param(classes.BUNDLE, "savedInstanceState"); - - JBlock body = onCreateView.body(); - body.assign(contentView, _super().invoke(onCreateView).arg(inflater).arg(container).arg(savedInstanceState)); - - JFieldRef contentViewId = helper.extractOneAnnotationFieldRef(holder, element, Res.LAYOUT, false); - - if (contentViewId != null) { - body._if(contentView.eq(_null())) // - ._then() // - .assign(contentView, inflater.invoke("inflate").arg(contentViewId).arg(container).arg(FALSE)); - } - - body._return(contentView); - } - - { - // onViewCreated - - JMethod onViewCreated = holder.generatedClass.method(PUBLIC, codeModel.VOID, "onViewCreated"); - onViewCreated.annotate(Override.class); - JVar view = onViewCreated.param(classes.VIEW, "view"); - JVar savedInstanceState = onViewCreated.param(classes.BUNDLE, "savedInstanceState"); - - JBlock onViewCreatedBody = onViewCreated.body(); - - onViewCreatedBody.invoke(_super(), onViewCreated).arg(view).arg(savedInstanceState); - - holder.invokeViewChanged(onViewCreatedBody); - } - - { - // findViewById - - JMethod findViewById = holder.generatedClass.method(PUBLIC, classes.VIEW, "findViewById"); - JVar idParam = findViewById.param(codeModel.INT, "id"); - - JBlock body = findViewById.body(); - - body._if(contentView.eq(_null())) // - ._then()._return(_null()); - - body._return(contentView.invoke(findViewById).arg(idParam)); - } - - { - // init if activity - holder.initIfActivityBody = holder.initBody; - holder.initActivityRef = holder.contextRef; - } - - addFragmentBuilder(codeModel, holder, eBeanClass); - } - - private void addFragmentBuilder(JCodeModel codeModel, EBeanHolder holder, JClass eBeanClass) throws JClassAlreadyExistsException { - JClass bundleClass = holder.classes().BUNDLE; - - { - holder.fragmentBuilderClass = holder.generatedClass._class(PUBLIC | STATIC, "FragmentBuilder_"); - holder.fragmentArgumentsBuilderField = holder.fragmentBuilderClass.field(PRIVATE, bundleClass, "args_"); - - { - // Constructor - JMethod constructor = holder.fragmentBuilderClass.constructor(PRIVATE); - JBlock constructorBody = constructor.body(); - constructorBody.assign(holder.fragmentArgumentsBuilderField, _new(bundleClass)); - } - - { - // build() - JMethod method = holder.fragmentBuilderClass.method(PUBLIC, eBeanClass, "build"); - JBlock body = method.body(); - - JVar fragment = body.decl(holder.generatedClass, "fragment_", _new(holder.generatedClass)); - body.invoke(fragment, "setArguments").arg(holder.fragmentArgumentsBuilderField); - body._return(fragment); - } - - { - // create() - JMethod method = holder.generatedClass.method(STATIC | PUBLIC, holder.fragmentBuilderClass, "builder"); - method.body()._return(_new(holder.fragmentBuilderClass)); - } - } - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EProviderProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EProviderProcessor.java deleted file mode 100644 index 0dd00fdee1..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EProviderProcessor.java +++ /dev/null @@ -1,86 +0,0 @@ -/** - * Copyright (C) 2010-2013 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._super; -import static com.sun.codemodel.JExpr.invoke; -import static com.sun.codemodel.JMod.FINAL; -import static com.sun.codemodel.JMod.PRIVATE; -import static com.sun.codemodel.JMod.PUBLIC; - -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; - -import org.androidannotations.annotations.EProvider; -import org.androidannotations.helper.ModelConstants; - -import com.sun.codemodel.ClassType; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JDefinedClass; -import com.sun.codemodel.JMethod; - -public class EProviderProcessor implements GeneratingElementProcessor { - - @Override - public String getTarget() { - return EProvider.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeansHolder eBeansHolder) throws Exception { - - TypeElement typeElement = (TypeElement) element; - - String annotatedComponentQualifiedName = typeElement.getQualifiedName().toString(); - - String generatedComponentQualifiedName = annotatedComponentQualifiedName + ModelConstants.GENERATION_SUFFIX; - - JDefinedClass generatedClass = codeModel._class(PUBLIC | FINAL, generatedComponentQualifiedName, ClassType.CLASS); - - EBeanHolder holder = eBeansHolder.create(element, EProvider.class, generatedClass); - - JClass annotatedComponent = codeModel.directClass(annotatedComponentQualifiedName); - - holder.generatedClass._extends(annotatedComponent); - - holder.contextRef = invoke("getContext"); - - JMethod init = holder.generatedClass.method(PRIVATE, codeModel.VOID, "init_"); - holder.initBody = init.body(); - { - // onCreate - JMethod onCreate = holder.generatedClass.method(PUBLIC, codeModel.BOOLEAN, "onCreate"); - onCreate.annotate(Override.class); - JBlock onCreateBody = onCreate.body(); - onCreateBody.invoke(init); - onCreateBody._return(invoke(_super(), onCreate)); - } - - { - /* - * Setting to null shouldn't be a problem as long as we don't allow - * - * @App and @Extra on this component - */ - holder.initIfActivityBody = null; - holder.initActivityRef = null; - } - - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EReceiverProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EReceiverProcessor.java deleted file mode 100644 index 15e1b963b9..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EReceiverProcessor.java +++ /dev/null @@ -1,94 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.JMod.FINAL; -import static com.sun.codemodel.JMod.PRIVATE; -import static com.sun.codemodel.JMod.PUBLIC; - -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; - -import org.androidannotations.annotations.EReceiver; -import org.androidannotations.helper.ModelConstants; -import org.androidannotations.processing.EBeansHolder.Classes; - -import com.sun.codemodel.ClassType; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JDefinedClass; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JFieldVar; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JVar; - -public class EReceiverProcessor implements GeneratingElementProcessor { - - @Override - public String getTarget() { - return EReceiver.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeansHolder eBeansHolder) throws Exception { - - TypeElement typeElement = (TypeElement) element; - - String annotatedComponentQualifiedName = typeElement.getQualifiedName().toString(); - - String generatedComponentQualifiedName = annotatedComponentQualifiedName + ModelConstants.GENERATION_SUFFIX; - - JDefinedClass generatedClass = codeModel._class(PUBLIC | FINAL, generatedComponentQualifiedName, ClassType.CLASS); - - EBeanHolder holder = eBeansHolder.create(element, EReceiver.class, generatedClass); - - JClass annotatedComponent = codeModel.directClass(annotatedComponentQualifiedName); - - holder.generatedClass._extends(annotatedComponent); - - Classes classes = holder.classes(); - - JFieldVar contextField = holder.generatedClass.field(PRIVATE, classes.CONTEXT, "context_"); - holder.contextRef = contextField; - - JMethod init = holder.generatedClass.method(PRIVATE, codeModel.VOID, "init_"); - holder.initBody = init.body(); - { - // onReceive - JMethod onReceive = holder.generatedClass.method(PUBLIC, codeModel.VOID, "onReceive"); - JVar contextParam = onReceive.param(classes.CONTEXT, "context"); - JVar intentParam = onReceive.param(classes.INTENT, "intent"); - onReceive.annotate(Override.class); - JBlock onReceiveBody = onReceive.body(); - onReceiveBody.assign(contextField, contextParam); - onReceiveBody.invoke(init); - onReceiveBody.invoke(JExpr._super(), onReceive).arg(contextParam).arg(intentParam); - } - - { - /* - * Setting to null shouldn't be a problem as long as we don't allow - * - * @App and @Extra on this component - */ - holder.initIfActivityBody = null; - holder.initActivityRef = null; - } - - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EServiceProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EServiceProcessor.java deleted file mode 100644 index 8b33bf5e09..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EServiceProcessor.java +++ /dev/null @@ -1,95 +0,0 @@ -/** - * Copyright (C) 2010-2013 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._this; -import static com.sun.codemodel.JMod.FINAL; -import static com.sun.codemodel.JMod.PRIVATE; -import static com.sun.codemodel.JMod.PUBLIC; - -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; - -import org.androidannotations.annotations.EService; -import org.androidannotations.helper.APTCodeModelHelper; -import org.androidannotations.helper.ModelConstants; - -import com.sun.codemodel.ClassType; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JDefinedClass; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JMethod; - -public class EServiceProcessor implements GeneratingElementProcessor { - - private final APTCodeModelHelper aptCodeModelHelper; - - public EServiceProcessor() { - aptCodeModelHelper = new APTCodeModelHelper(); - } - - @Override - public String getTarget() { - return EService.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeansHolder eBeansHolder) throws Exception { - - TypeElement typeElement = (TypeElement) element; - - String annotatedComponentQualifiedName = typeElement.getQualifiedName().toString(); - - String generatedComponentQualifiedName = annotatedComponentQualifiedName + ModelConstants.GENERATION_SUFFIX; - - JDefinedClass generatedClass = codeModel._class(PUBLIC | FINAL, generatedComponentQualifiedName, ClassType.CLASS); - - EBeanHolder holder = eBeansHolder.create(element, EService.class, generatedClass); - - JClass annotatedComponent = codeModel.directClass(annotatedComponentQualifiedName); - - holder.generatedClass._extends(annotatedComponent); - - holder.contextRef = _this(); - - JMethod init = holder.generatedClass.method(PRIVATE, codeModel.VOID, "init_"); - holder.initBody = init.body(); - { - // onCreate - JMethod onCreate = holder.generatedClass.method(PUBLIC, codeModel.VOID, "onCreate"); - onCreate.annotate(Override.class); - JBlock onCreateBody = onCreate.body(); - onCreateBody.invoke(init); - onCreateBody.invoke(JExpr._super(), onCreate); - } - - { - /* - * Setting to null shouldn't be a problem as long as we don't allow - * - * @App and @Extra on this component - */ - holder.initIfActivityBody = null; - holder.initActivityRef = null; - } - - aptCodeModelHelper.addServiceIntentBuilder(codeModel, holder); - - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EViewGroupProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EViewGroupProcessor.java deleted file mode 100644 index ca773da530..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EViewGroupProcessor.java +++ /dev/null @@ -1,150 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.invoke; -import static com.sun.codemodel.JMod.PRIVATE; -import static com.sun.codemodel.JMod.PUBLIC; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.Modifier; -import javax.lang.model.element.TypeElement; - -import org.androidannotations.annotations.EViewGroup; -import org.androidannotations.helper.APTCodeModelHelper; -import org.androidannotations.helper.IdAnnotationHelper; -import org.androidannotations.helper.ModelConstants; -import org.androidannotations.processing.EBeansHolder.Classes; -import org.androidannotations.rclass.IRClass; -import org.androidannotations.rclass.IRClass.Res; - -import com.sun.codemodel.ClassType; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JDefinedClass; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JFieldRef; -import com.sun.codemodel.JFieldVar; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JMod; -import com.sun.codemodel.JType; - -public class EViewGroupProcessor implements GeneratingElementProcessor { - - private static final String ALREADY_INFLATED_COMMENT = "" // + - + "The mAlreadyInflated_ hack is needed because of an Android bug\n" // + - + "which leads to infinite calls of onFinishInflate()\n" // - + "when inflating a layout with a parent and using\n" // - + "the tag." // - ; - - private static final String SUPPRESS_WARNING_COMMENT = "" // - + "We use @SuppressWarning here because our java code\n" // - + "generator doesn't know that there is no need\n" // - + "to import OnXXXListeners from View as we already\n" // - + "are in a View." // - ; - - private final APTCodeModelHelper codeModelHelper; - - private final IdAnnotationHelper helper; - - public EViewGroupProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - codeModelHelper = new APTCodeModelHelper(); - helper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - } - - @Override - public String getTarget() { - return EViewGroup.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeansHolder eBeansHolder) throws Exception { - - Classes classes = eBeansHolder.classes(); - - TypeElement typeElement = (TypeElement) element; - - String eBeanQualifiedName = typeElement.getQualifiedName().toString(); - - String generatedBeanQualifiedName = eBeanQualifiedName + ModelConstants.GENERATION_SUFFIX; - - int modifiers; - if (element.getModifiers().contains(Modifier.ABSTRACT)) { - modifiers = JMod.PUBLIC | JMod.ABSTRACT; - } else { - modifiers = JMod.PUBLIC | JMod.FINAL; - } - - JDefinedClass generatedClass = codeModel._class(modifiers, generatedBeanQualifiedName, ClassType.CLASS); - - EBeanHolder holder = eBeansHolder.create(element, EViewGroup.class, generatedClass); - - JClass eBeanClass = codeModel.directClass(eBeanQualifiedName); - - holder.generatedClass._extends(eBeanClass); - - holder.generatedClass.annotate(SuppressWarnings.class).param("value", "unused"); - holder.generatedClass.javadoc().append(SUPPRESS_WARNING_COMMENT); - - { - holder.contextRef = holder.generatedClass.field(PRIVATE, classes.CONTEXT, "context_"); - } - - JMethod init; - { - // init - init = holder.generatedClass.method(PRIVATE, codeModel.VOID, "init_"); - holder.initBody = init.body(); - holder.wrapInitWithNotifier(); - holder.initBody.assign((JFieldVar) holder.contextRef, JExpr.invoke("getContext")); - } - - JFieldVar mAlreadyInflated_ = holder.generatedClass.field(PRIVATE, JType.parse(codeModel, "boolean"), "mAlreadyInflated_", JExpr.FALSE); - - // onFinishInflate - JMethod onFinishInflate = holder.generatedClass.method(PUBLIC, codeModel.VOID, "onFinishInflate"); - onFinishInflate.annotate(Override.class); - onFinishInflate.javadoc().append(ALREADY_INFLATED_COMMENT); - - JBlock ifNotInflated = onFinishInflate.body()._if(JExpr.ref("mAlreadyInflated_").not())._then(); - ifNotInflated.assign(mAlreadyInflated_, JExpr.TRUE); - - JFieldRef contentViewId = helper.extractOneAnnotationFieldRef(holder, element, Res.LAYOUT, false); - - if (contentViewId != null) { - ifNotInflated.invoke("inflate").arg(invoke("getContext")).arg(contentViewId).arg(JExpr._this()); - } - holder.invokeViewChanged(ifNotInflated); - - // finally - onFinishInflate.body().invoke(JExpr._super(), "onFinishInflate"); - - codeModelHelper.copyConstructorsAndAddStaticEViewBuilders(element, codeModel, eBeanClass, holder, onFinishInflate, init); - - { - // init if activity - APTCodeModelHelper helper = new APTCodeModelHelper(); - holder.initIfActivityBody = helper.ifContextInstanceOfActivity(holder, holder.initBody); - holder.initActivityRef = helper.castContextToActivity(holder, holder.initIfActivityBody); - } - - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EViewProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EViewProcessor.java deleted file mode 100644 index ea8dadb588..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/EViewProcessor.java +++ /dev/null @@ -1,134 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.JMod.PRIVATE; -import static com.sun.codemodel.JMod.PUBLIC; - -import javax.lang.model.element.Element; -import javax.lang.model.element.Modifier; -import javax.lang.model.element.TypeElement; - -import org.androidannotations.annotations.EView; -import org.androidannotations.helper.APTCodeModelHelper; -import org.androidannotations.helper.ModelConstants; -import org.androidannotations.processing.EBeansHolder.Classes; - -import com.sun.codemodel.ClassType; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JDefinedClass; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JFieldVar; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JMod; -import com.sun.codemodel.JType; - -public class EViewProcessor implements GeneratingElementProcessor { - - private static final String ALREADY_INFLATED_COMMENT = "" // + - + "The mAlreadyInflated_ hack is needed because of an Android bug\n" // + - + "which leads to infinite calls of onFinishInflate()\n" // - + "when inflating a layout with a parent and using\n" // - + "the tag." // - ; - - private static final String SUPPRESS_WARNING_COMMENT = "" // - + "We use @SuppressWarning here because our java code\n" // - + "generator doesn't know that there is no need\n" // - + "to import OnXXXListeners from View as we already\n" // - + "are in a View." // - ; - - private final APTCodeModelHelper codeModelHelper; - - public EViewProcessor() { - codeModelHelper = new APTCodeModelHelper(); - } - - @Override - public String getTarget() { - return EView.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeansHolder eBeansHolder) throws Exception { - - Classes classes = eBeansHolder.classes(); - - TypeElement typeElement = (TypeElement) element; - - String eBeanQualifiedName = typeElement.getQualifiedName().toString(); - - String generatedBeanQualifiedName = eBeanQualifiedName + ModelConstants.GENERATION_SUFFIX; - - int modifiers; - if (element.getModifiers().contains(Modifier.ABSTRACT)) { - modifiers = JMod.PUBLIC | JMod.ABSTRACT; - } else { - modifiers = JMod.PUBLIC | JMod.FINAL; - } - - JDefinedClass generatedClass = codeModel._class(modifiers, generatedBeanQualifiedName, ClassType.CLASS); - EBeanHolder holder = eBeansHolder.create(element, EView.class, generatedClass); - - JClass eBeanClass = codeModel.directClass(eBeanQualifiedName); - - holder.generatedClass._extends(eBeanClass); - - holder.generatedClass.annotate(SuppressWarnings.class).param("value", "unused"); - holder.generatedClass.javadoc().append(SUPPRESS_WARNING_COMMENT); - - { - holder.contextRef = holder.generatedClass.field(PRIVATE, classes.CONTEXT, "context_"); - } - - JMethod init; - { - // init - init = holder.generatedClass.method(PRIVATE, codeModel.VOID, "init_"); - holder.initBody = init.body(); - holder.wrapInitWithNotifier(); - holder.initBody.assign((JFieldVar) holder.contextRef, JExpr.invoke("getContext")); - } - - JFieldVar mAlreadyInflated_ = holder.generatedClass.field(PRIVATE, JType.parse(codeModel, "boolean"), "mAlreadyInflated_", JExpr.FALSE); - - // onFinishInflate - JMethod onFinishInflate = holder.generatedClass.method(PUBLIC, codeModel.VOID, "onFinishInflate"); - onFinishInflate.annotate(Override.class); - onFinishInflate.javadoc().append(ALREADY_INFLATED_COMMENT); - - JBlock ifNotInflated = onFinishInflate.body()._if(JExpr.ref("mAlreadyInflated_").not())._then(); - ifNotInflated.assign(mAlreadyInflated_, JExpr.TRUE); - - holder.invokeViewChanged(ifNotInflated); - - // finally - onFinishInflate.body().invoke(JExpr._super(), "onFinishInflate"); - - codeModelHelper.copyConstructorsAndAddStaticEViewBuilders(element, codeModel, eBeanClass, holder, onFinishInflate, init); - - { - // init if activity - holder.initIfActivityBody = codeModelHelper.ifContextInstanceOfActivity(holder, holder.initBody); - holder.initActivityRef = codeModelHelper.castContextToActivity(holder, holder.initIfActivityBody); - } - - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ExtraProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ExtraProcessor.java deleted file mode 100644 index 2e92d3c51f..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ExtraProcessor.java +++ /dev/null @@ -1,227 +0,0 @@ -/** - * Copyright (C) 2010-2013 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._null; -import static com.sun.codemodel.JExpr._super; -import static com.sun.codemodel.JExpr._this; -import static com.sun.codemodel.JExpr.cast; -import static com.sun.codemodel.JExpr.invoke; -import static com.sun.codemodel.JExpr.lit; -import static com.sun.codemodel.JMod.FINAL; -import static com.sun.codemodel.JMod.PRIVATE; -import static com.sun.codemodel.JMod.PUBLIC; -import static com.sun.codemodel.JMod.STATIC; -import static org.androidannotations.helper.CanonicalNameConstants.PARCELABLE; -import static org.androidannotations.helper.CanonicalNameConstants.SERIALIZABLE; -import static org.androidannotations.helper.CanonicalNameConstants.STRING; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.type.TypeKind; -import javax.lang.model.type.TypeMirror; -import javax.lang.model.util.Elements; -import javax.lang.model.util.Types; - -import org.androidannotations.annotations.Extra; -import org.androidannotations.helper.APTCodeModelHelper; -import org.androidannotations.helper.CaseHelper; -import org.androidannotations.processing.EBeansHolder.Classes; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JCatchBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JFieldRef; -import com.sun.codemodel.JFieldVar; -import com.sun.codemodel.JInvocation; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JMod; -import com.sun.codemodel.JPrimitiveType; -import com.sun.codemodel.JTryBlock; -import com.sun.codemodel.JType; -import com.sun.codemodel.JTypeVar; -import com.sun.codemodel.JVar; - -public class ExtraProcessor implements DecoratingElementProcessor { - - private final APTCodeModelHelper helper = new APTCodeModelHelper(); - private final ProcessingEnvironment processingEnv; - - public ExtraProcessor(ProcessingEnvironment processingEnv) { - this.processingEnv = processingEnv; - } - - @Override - public String getTarget() { - return Extra.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - Extra annotation = element.getAnnotation(Extra.class); - String extraKey = annotation.value(); - String fieldName = element.getSimpleName().toString(); - - if (extraKey.isEmpty()) { - extraKey = fieldName; - } - - TypeMirror elementType = element.asType(); - boolean isPrimitive = elementType.getKind().isPrimitive(); - - Classes classes = holder.classes(); - - if (!isPrimitive && holder.cast == null) { - generateCastMethod(codeModel, holder); - } - - if (holder.extras == null) { - injectExtras(holder, codeModel); - } - - String staticFieldName; - if (fieldName.endsWith("Extra")) { - staticFieldName = CaseHelper.camelCaseToUpperSnakeCase(fieldName); - } else { - staticFieldName = CaseHelper.camelCaseToUpperSnakeCase(fieldName + "Extra"); - } - - JFieldVar extraKeyField = holder.generatedClass.field(PUBLIC | STATIC | FINAL, classes.STRING, staticFieldName, lit(extraKey)); - - JBlock ifContainsKey = holder.extrasNotNullBlock._if(JExpr.invoke(holder.extras, "containsKey").arg(extraKeyField))._then(); - - JTryBlock containsKeyTry = ifContainsKey._try(); - - JFieldRef extraField = JExpr.ref(fieldName); - - if (isPrimitive) { - JPrimitiveType primitiveType = JType.parse(codeModel, elementType.toString()); - JClass wrapperType = primitiveType.boxify(); - containsKeyTry.body().assign(extraField, JExpr.cast(wrapperType, holder.extras.invoke("get").arg(extraKeyField))); - } else { - containsKeyTry.body().assign(extraField, JExpr.invoke(holder.cast).arg(holder.extras.invoke("get").arg(extraKeyField))); - } - - JCatchBlock containsKeyCatch = containsKeyTry._catch(classes.CLASS_CAST_EXCEPTION); - JVar exceptionParam = containsKeyCatch.param("e"); - - JInvocation logError = classes.LOG.staticInvoke("e"); - - logError.arg(holder.generatedClass.name()); - logError.arg("Could not cast extra to expected type, the field is left to its default value"); - logError.arg(exceptionParam); - - containsKeyCatch.body().add(logError); - - /* - * holder.intentBuilderClass may be null if the annotated component is - * an abstract activity - */ - if (holder.intentBuilderClass != null) { - { - // flags() - JMethod method = holder.intentBuilderClass.method(PUBLIC, holder.intentBuilderClass, fieldName); - - boolean castToSerializable = false; - boolean castToParcelable = false; - TypeMirror extraType = elementType; - if (extraType.getKind() == TypeKind.DECLARED) { - Elements elementUtils = processingEnv.getElementUtils(); - Types typeUtils = processingEnv.getTypeUtils(); - TypeMirror parcelableType = elementUtils.getTypeElement(PARCELABLE).asType(); - if (!typeUtils.isSubtype(extraType, parcelableType)) { - TypeMirror stringType = elementUtils.getTypeElement(STRING).asType(); - if (!typeUtils.isSubtype(extraType, stringType)) { - castToSerializable = true; - } - } else { - TypeMirror serializableType = elementUtils.getTypeElement(SERIALIZABLE).asType(); - if (typeUtils.isSubtype(extraType, serializableType)) { - castToParcelable = true; - } - } - } - JClass paramClass = helper.typeMirrorToJClass(extraType, holder); - JVar extraParam = method.param(paramClass, fieldName); - JBlock body = method.body(); - JInvocation invocation = body.invoke(holder.intentField, "putExtra").arg(extraKeyField); - if (castToSerializable) { - invocation.arg(cast(classes.SERIALIZABLE, extraParam)); - } else if (castToParcelable) { - invocation.arg(cast(classes.PARCELABLE, extraParam)); - } else { - invocation.arg(extraParam); - } - body._return(_this()); - } - } - - } - - private void generateCastMethod(JCodeModel codeModel, EBeanHolder holder) { - JType objectType = codeModel._ref(Object.class); - JMethod method = holder.generatedClass.method(JMod.PRIVATE, objectType, "cast_"); - JTypeVar genericType = method.generify("T"); - method.type(genericType); - JVar objectParam = method.param(objectType, "object"); - method.annotate(SuppressWarnings.class).param("value", "unchecked"); - method.body()._return(JExpr.cast(genericType, objectParam)); - holder.cast = method; - } - - /** - * Adds call to injectExtras_() in onCreate and setIntent() methods. - */ - private void injectExtras(EBeanHolder holder, JCodeModel codeModel) { - - Classes classes = holder.classes(); - - JMethod injectExtrasMethod = holder.generatedClass.method(PRIVATE, codeModel.VOID, "injectExtras_"); - - overrideSetIntent(holder, codeModel, injectExtrasMethod); - - injectExtrasOnInit(holder, classes.INTENT, injectExtrasMethod); - - JBlock injectExtrasBody = injectExtrasMethod.body(); - - JVar intent = injectExtrasBody.decl(classes.INTENT, "intent_", invoke("getIntent")); - - holder.extras = injectExtrasBody.decl(classes.BUNDLE, "extras_"); - holder.extras.init(intent.invoke("getExtras")); - - holder.extrasNotNullBlock = injectExtrasBody._if(holder.extras.ne(_null()))._then(); - } - - private void overrideSetIntent(EBeanHolder holder, JCodeModel codeModel, JMethod initIntentMethod) { - if (holder.intentBuilderClass != null) { - - JMethod setIntentMethod = holder.generatedClass.method(PUBLIC, codeModel.VOID, "setIntent"); - setIntentMethod.annotate(Override.class); - JVar methodParam = setIntentMethod.param(holder.classes().INTENT, "newIntent"); - - JBlock setIntentBody = setIntentMethod.body(); - - setIntentBody.invoke(_super(), setIntentMethod).arg(methodParam); - setIntentBody.invoke(initIntentMethod); - } - } - - private void injectExtrasOnInit(EBeanHolder holder, JClass intentClass, JMethod injectExtrasMethod) { - holder.initBody.invoke(injectExtrasMethod); - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FocusChangeProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FocusChangeProcessor.java deleted file mode 100644 index a8bf27df11..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FocusChangeProcessor.java +++ /dev/null @@ -1,85 +0,0 @@ -/** - * Copyright (C) 2010-2013 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/FragmentArgProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FragmentArgProcessor.java deleted file mode 100644 index caa87de8eb..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FragmentArgProcessor.java +++ /dev/null @@ -1,150 +0,0 @@ -/** - * Copyright (C) 2010-2013 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._null; -import static com.sun.codemodel.JExpr._this; -import static com.sun.codemodel.JExpr.invoke; -import static com.sun.codemodel.JExpr.ref; -import static com.sun.codemodel.JMod.PRIVATE; -import static com.sun.codemodel.JMod.PUBLIC; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.type.TypeMirror; - -import org.androidannotations.annotations.FragmentArg; -import org.androidannotations.helper.APTCodeModelHelper; -import org.androidannotations.helper.AnnotationHelper; -import org.androidannotations.helper.BundleHelper; -import org.androidannotations.processing.EBeansHolder.Classes; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JCatchBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -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.JTryBlock; -import com.sun.codemodel.JVar; - -public class FragmentArgProcessor implements DecoratingElementProcessor { - - private final APTCodeModelHelper helper = new APTCodeModelHelper(); - private final AnnotationHelper annotationHelper; - - public FragmentArgProcessor(ProcessingEnvironment processingEnv) { - annotationHelper = new AnnotationHelper(processingEnv); - } - - @Override - public String getTarget() { - return FragmentArg.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) throws Exception { - FragmentArg annotation = element.getAnnotation(FragmentArg.class); - String argKey = annotation.value(); - String fieldName = element.getSimpleName().toString(); - - if (argKey.isEmpty()) { - argKey = fieldName; - } - - TypeMirror elementType = element.asType(); - - Classes classes = holder.classes(); - - if (holder.fragmentArguments == null) { - injectFragmentArguments(holder, codeModel); - } - - JBlock ifContainsKey = holder.fragmentArgumentsNotNullBlock._if(JExpr.invoke(holder.fragmentArguments, "containsKey").arg(argKey))._then(); - - JTryBlock containsKeyTry = ifContainsKey._try(); - - JFieldRef argField = ref(fieldName); - - BundleHelper bundleHelper = new BundleHelper(annotationHelper, element); - - JInvocation restoreMethodCall = JExpr.invoke(holder.fragmentArguments, bundleHelper.getMethodNameToRestore()).arg(argKey); - if (bundleHelper.restoreCallNeedCastStatement()) { - - JClass jclass = helper.typeMirrorToJClass(element.asType(), holder); - JExpression castStatement = JExpr.cast(jclass, restoreMethodCall); - containsKeyTry.body().assign(argField, castStatement); - - if (bundleHelper.restoreCallNeedsSuppressWarning()) { - if (holder.fragmentArgumentsInjectMethod.annotations().size() == 0) { - holder.fragmentArgumentsInjectMethod.annotate(SuppressWarnings.class).param("value", "unchecked"); - } - } - - } else { - containsKeyTry.body().assign(argField, restoreMethodCall); - } - - JCatchBlock containsKeyCatch = containsKeyTry._catch(classes.CLASS_CAST_EXCEPTION); - JVar exceptionParam = containsKeyCatch.param("e"); - - JInvocation logError = classes.LOG.staticInvoke("e"); - - logError.arg(holder.generatedClass.name()); - logError.arg("Could not cast argument to the expected type, the field is left to its default value"); - logError.arg(exceptionParam); - - containsKeyCatch.body().add(logError); - - { - JMethod method = holder.fragmentBuilderClass.method(PUBLIC, holder.fragmentBuilderClass, fieldName); - - JClass paramClass = helper.typeMirrorToJClass(elementType, holder); - JVar arg = method.param(paramClass, fieldName); - // Assign - method.body().invoke(holder.fragmentArgumentsBuilderField, bundleHelper.getMethodNameToSave()).arg(argKey).arg(arg); - method.body()._return(_this()); - } - - } - - /** - * Adds call to injectFragmentArguments_() in onCreate and setIntent() - * methods. - */ - private void injectFragmentArguments(EBeanHolder holder, JCodeModel codeModel) { - - Classes classes = holder.classes(); - - holder.fragmentArgumentsInjectMethod = holder.generatedClass.method(PRIVATE, codeModel.VOID, "injectFragmentArguments_"); - - injectArgumentsOnInit(holder, classes.INTENT, holder.fragmentArgumentsInjectMethod); - - JBlock injectArgumentsBody = holder.fragmentArgumentsInjectMethod.body(); - - holder.fragmentArguments = injectArgumentsBody.decl(classes.BUNDLE, "args_"); - holder.fragmentArguments.init(invoke("getArguments")); - - holder.fragmentArgumentsNotNullBlock = injectArgumentsBody._if(holder.fragmentArguments.ne(_null()))._then(); - } - - private void injectArgumentsOnInit(EBeanHolder holder, JClass intentClass, JMethod injectArgumentsMethod) { - holder.initBody.invoke(injectArgumentsMethod); - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FragmentByIdProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FragmentByIdProcessor.java deleted file mode 100644 index 29bf61750b..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FragmentByIdProcessor.java +++ /dev/null @@ -1,111 +0,0 @@ -/** - * Copyright (C) 2010-2013 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._null; -import static com.sun.codemodel.JExpr.cast; -import static com.sun.codemodel.JExpr.invoke; -import static com.sun.codemodel.JExpr.ref; -import static com.sun.codemodel.JMod.PRIVATE; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; -import javax.lang.model.type.TypeMirror; - -import org.androidannotations.annotations.FragmentById; -import org.androidannotations.helper.CanonicalNameConstants; -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.JFieldRef; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JVar; - -public class FragmentByIdProcessor implements DecoratingElementProcessor { - - private final IdAnnotationHelper annotationHelper; - - public FragmentByIdProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - } - - @Override - public String getTarget() { - return FragmentById.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - - Classes classes = holder.classes(); - - String fieldName = element.getSimpleName().toString(); - - TypeMirror elementType = element.asType(); - String typeQualifiedName = elementType.toString(); - - TypeElement nativeFragmentElement = annotationHelper.typeElementFromQualifiedName(CanonicalNameConstants.FRAGMENT); - - JMethod findFragmentById; - if (nativeFragmentElement != null && annotationHelper.isSubtype(elementType, nativeFragmentElement.asType())) { - // Injecting native fragment - findFragmentById = null; - - if (holder.findNativeFragmentById == null) { - holder.findNativeFragmentById = holder.generatedClass.method(PRIVATE, classes.FRAGMENT, "findNativeFragmentById"); - JVar idParam = holder.findNativeFragmentById.param(codeModel.INT, "id"); - - JBlock body = holder.findNativeFragmentById.body(); - body._if(holder.contextRef._instanceof(classes.ACTIVITY).not())._then()._return(_null()); - - JVar activityVar = body.decl(classes.ACTIVITY, "activity_", cast(classes.ACTIVITY, holder.contextRef)); - - body._return(activityVar.invoke("getFragmentManager").invoke("findFragmentById").arg(idParam)); - } - - findFragmentById = holder.findNativeFragmentById; - - } else { - // Injecting support fragment - - if (holder.findSupportFragmentById == null) { - holder.findSupportFragmentById = holder.generatedClass.method(PRIVATE, classes.SUPPORT_V4_FRAGMENT, "findSupportFragmentById"); - JVar idParam = holder.findSupportFragmentById.param(codeModel.INT, "id"); - - JBlock body = holder.findSupportFragmentById.body(); - - body._if(holder.contextRef._instanceof(classes.FRAGMENT_ACTIVITY).not())._then()._return(_null()); - - JVar activityVar = body.decl(classes.FRAGMENT_ACTIVITY, "activity_", cast(classes.FRAGMENT_ACTIVITY, holder.contextRef)); - - body._return(activityVar.invoke("getSupportFragmentManager").invoke("findFragmentById").arg(idParam)); - } - - findFragmentById = holder.findSupportFragmentById; - } - - JBlock methodBody = holder.onViewChanged().body(); - - JFieldRef idRef = annotationHelper.extractOneAnnotationFieldRef(holder, element, Res.ID, true); - - methodBody.assign(ref(fieldName), cast(holder.refClass(typeQualifiedName), invoke(findFragmentById).arg(idRef))); - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FragmentByTagProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FragmentByTagProcessor.java deleted file mode 100644 index e5e2d1676a..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FragmentByTagProcessor.java +++ /dev/null @@ -1,112 +0,0 @@ -/** - * Copyright (C) 2010-2013 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._null; -import static com.sun.codemodel.JExpr.cast; -import static com.sun.codemodel.JExpr.invoke; -import static com.sun.codemodel.JExpr.lit; -import static com.sun.codemodel.JExpr.ref; -import static com.sun.codemodel.JMod.PRIVATE; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.type.TypeMirror; - -import org.androidannotations.annotations.FragmentByTag; -import org.androidannotations.helper.AnnotationHelper; -import org.androidannotations.helper.CanonicalNameConstants; -import org.androidannotations.processing.EBeansHolder.Classes; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JVar; - -public class FragmentByTagProcessor implements DecoratingElementProcessor { - - private final AnnotationHelper annotationHelper; - - public FragmentByTagProcessor(ProcessingEnvironment processingEnv) { - annotationHelper = new AnnotationHelper(processingEnv); - } - - @Override - public String getTarget() { - return FragmentByTag.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - Classes classes = holder.classes(); - - String fieldName = element.getSimpleName().toString(); - - TypeMirror elementType = element.asType(); - String typeQualifiedName = elementType.toString(); - - FragmentByTag annotation = element.getAnnotation(FragmentByTag.class); - String tagValue = annotation.value(); - - if (tagValue.equals("")) { - tagValue = fieldName; - } - - TypeMirror nativeFragmentType = annotationHelper.typeElementFromQualifiedName(CanonicalNameConstants.FRAGMENT).asType(); - - JMethod findFragmentByTag; - if (annotationHelper.isSubtype(elementType, nativeFragmentType)) { - // Injecting native fragment - - findFragmentByTag = null; - - if (holder.findNativeFragmentByTag == null) { - holder.findNativeFragmentByTag = holder.generatedClass.method(PRIVATE, classes.FRAGMENT, "findNativeFragmentByTag"); - JVar tagParam = holder.findNativeFragmentByTag.param(classes.STRING, "tag"); - - JBlock body = holder.findNativeFragmentByTag.body(); - body._if(holder.contextRef._instanceof(classes.ACTIVITY).not())._then()._return(_null()); - - JVar activityVar = body.decl(classes.ACTIVITY, "activity_", cast(classes.ACTIVITY, holder.contextRef)); - - body._return(activityVar.invoke("getFragmentManager").invoke("findFragmentByTag").arg(tagParam)); - } - - findFragmentByTag = holder.findNativeFragmentByTag; - - } else { - // Injecting support fragment - - if (holder.findSupportFragmentByTag == null) { - holder.findSupportFragmentByTag = holder.generatedClass.method(PRIVATE, classes.SUPPORT_V4_FRAGMENT, "findSupportFragmentByTag"); - JVar tagParam = holder.findSupportFragmentByTag.param(classes.STRING, "tag"); - - JBlock body = holder.findSupportFragmentByTag.body(); - - body._if(holder.contextRef._instanceof(classes.FRAGMENT_ACTIVITY).not())._then()._return(_null()); - - JVar activityVar = body.decl(classes.FRAGMENT_ACTIVITY, "activity_", cast(classes.FRAGMENT_ACTIVITY, holder.contextRef)); - - body._return(activityVar.invoke("getSupportFragmentManager").invoke("findFragmentByTag").arg(tagParam)); - } - - findFragmentByTag = holder.findSupportFragmentByTag; - } - - JBlock methodBody = holder.onViewChanged().body(); - methodBody.assign(ref(fieldName), cast(holder.refClass(typeQualifiedName), invoke(findFragmentByTag).arg(lit(tagValue)))); - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FromHtmlProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FromHtmlProcessor.java deleted file mode 100644 index a58e496b64..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FromHtmlProcessor.java +++ /dev/null @@ -1,63 +0,0 @@ -/** - * Copyright (C) 2010-2013 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._null; -import static com.sun.codemodel.JExpr.ref; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; - -import org.androidannotations.annotations.FromHtml; -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.JFieldRef; - -public class FromHtmlProcessor implements DecoratingElementProcessor { - - private final IdAnnotationHelper annotationHelper; - - public FromHtmlProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - } - - @Override - public String getTarget() { - return FromHtml.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) throws Exception { - Classes classes = holder.classes(); - - String fieldName = element.getSimpleName().toString(); - - JFieldRef idRef = annotationHelper.extractOneAnnotationFieldRef(holder, element, Res.STRING, true); - - JBlock methodBody = holder.onViewChanged().body(); - - // - methodBody. // - _if(ref(fieldName).ne(_null())). // - _then() // - .invoke(ref(fieldName), "setText").arg(classes.HTML.staticInvoke("fromHtml").arg(holder.contextRef.invoke("getString").arg(idRef))); - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FullscreenProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FullscreenProcessor.java deleted file mode 100644 index 6373d87695..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/FullscreenProcessor.java +++ /dev/null @@ -1,44 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.invoke; - -import javax.lang.model.element.Element; - -import org.androidannotations.annotations.Fullscreen; - -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JFieldRef; -import com.sun.codemodel.JInvocation; - -public class FullscreenProcessor implements DecoratingElementProcessor { - - @Override - public String getTarget() { - return Fullscreen.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - - JFieldRef fullScreen = holder.classes().WINDOW_MANAGER_LAYOUT_PARAMS.staticRef("FLAG_FULLSCREEN"); - - JInvocation arg = invoke(invoke("getWindow"), "setFlags").arg(fullScreen).arg(fullScreen); - holder.initBody.add(arg); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/GeneratingElementProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/GeneratingElementProcessor.java deleted file mode 100644 index f385371d5f..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/GeneratingElementProcessor.java +++ /dev/null @@ -1,27 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 javax.lang.model.element.Element; - -import org.androidannotations.helper.HasTarget; -import com.sun.codemodel.JCodeModel; - -public interface GeneratingElementProcessor extends HasTarget { - - void process(Element element, JCodeModel codeModel, EBeansHolder eBeansHolder) throws Exception; - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/HierarchyViewerSupportProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/HierarchyViewerSupportProcessor.java deleted file mode 100644 index dd2fb80bf1..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/HierarchyViewerSupportProcessor.java +++ /dev/null @@ -1,83 +0,0 @@ -/** - * Copyright (C) 2010-2013 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._super; -import static com.sun.codemodel.JExpr._this; - -import javax.lang.model.element.Element; - -import org.androidannotations.annotations.HierarchyViewerSupport; -import org.androidannotations.api.ViewServer; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JInvocation; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JMod; - -public class HierarchyViewerSupportProcessor implements DecoratingElementProcessor { - - @Override - public String getTarget() { - return HierarchyViewerSupport.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - - holder.generateApiClass(element, ViewServer.class); - - // Methods - onViewChanged(codeModel, holder); - onDestroyMethod(codeModel, holder); - onResumeMethod(codeModel, holder); - } - - private void onViewChanged(JCodeModel codeModel, EBeanHolder holder) { - JInvocation viewServerInvocation = holder.classes().VIEW_SERVER.staticInvoke("get").arg(_this()); - holder.onViewChanged().body().invoke(viewServerInvocation, "addWindow").arg(_this()); - } - - private void onDestroyMethod(JCodeModel codeModel, EBeanHolder holder) { - JBlock onDestroyBlock = holder.onDestroyBlock; - - if (onDestroyBlock == null) { - JMethod method = holder.generatedClass.method(JMod.PUBLIC, codeModel.VOID, "onDestroy"); - method.annotate(Override.class); - holder.onDestroyBlock = method.body(); - holder.onDestroyBlock.invoke(_super(), method); - } - - JInvocation viewServerInvocation = holder.classes().VIEW_SERVER.staticInvoke("get").arg(_this()); - holder.onDestroyBlock.invoke(viewServerInvocation, "removeWindow").arg(_this()); - } - - private void onResumeMethod(JCodeModel codeModel, EBeanHolder holder) { - JBlock onResumeBlock = holder.onResumeBlock; - - if (onResumeBlock == null) { - JMethod method = holder.generatedClass.method(JMod.PUBLIC, codeModel.VOID, "onResume"); - method.annotate(Override.class); - holder.onResumeBlock = method.body(); - holder.onResumeBlock.invoke(_super(), method); - } - - JInvocation viewServerInvocation = holder.classes().VIEW_SERVER.staticInvoke("get").arg(_this()); - holder.onResumeBlock.invoke(viewServerInvocation, "setFocusedWindow").arg(_this()); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/HttpsClientProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/HttpsClientProcessor.java deleted file mode 100644 index 341cae2639..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/HttpsClientProcessor.java +++ /dev/null @@ -1,187 +0,0 @@ -/** - * Copyright (C) 2010-2013 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._super; -import static com.sun.codemodel.JExpr.cast; -import static com.sun.codemodel.JExpr.invoke; -import static com.sun.codemodel.JExpr.lit; -import static com.sun.codemodel.JExpr.ref; - -import javax.lang.model.element.Element; - -import org.androidannotations.annotations.HttpsClient; -import org.androidannotations.annotations.ResId; -import org.androidannotations.processing.EBeansHolder.Classes; -import org.androidannotations.rclass.IRClass; -import org.androidannotations.rclass.IRClass.Res; -import org.androidannotations.rclass.IRInnerClass; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JCatchBlock; -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.JMod; -import com.sun.codemodel.JTryBlock; -import com.sun.codemodel.JVar; - -public class HttpsClientProcessor implements DecoratingElementProcessor { - - private final IRClass rClass; - - public HttpsClientProcessor(IRClass rClass) { - this.rClass = rClass; - } - - @Override - public String getTarget() { - return HttpsClient.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - - HttpsClient annotation = element.getAnnotation(HttpsClient.class); - int trustStoreRawId = annotation.trustStore(); - String trustStorePwd = annotation.trustStorePwd(); - - int keyStoreRawId = annotation.keyStore(); - String keyStorePwd = annotation.keyStorePwd(); - - boolean allowAllHostnames = annotation.allowAllHostnames(); - - boolean useCustomTrustStore = ResId.DEFAULT_VALUE != trustStoreRawId ? true : false; - boolean useCustomKeyStore = ResId.DEFAULT_VALUE != keyStoreRawId ? true : false; - - String fieldName = element.getSimpleName().toString(); - JBlock methodBody = holder.initBody; - - Classes classes = holder.classes(); - - JDefinedClass jAnonClass = codeModel.anonymousClass(classes.DEFAULT_HTTP_CLIENT); - - JMethod method = jAnonClass.method(JMod.PROTECTED, classes.CLIENT_CONNECTION_MANAGER, "createClientConnectionManager"); - method.annotate(Override.class); - - JTryBlock jTryBlock = method.body()._try(); - JVar jVarTrusted = null; - JVar jVarKeystore = null; - - if (useCustomKeyStore) { - jVarKeystore = jTryBlock.body().decl(classes.KEY_STORE, "keystore"); - jVarKeystore.init(classes.KEY_STORE.staticInvoke("getInstance").arg("BKS")); - } - - if (useCustomTrustStore || !useCustomTrustStore && useCustomKeyStore) { - /* - * use default trust store - */ - jVarTrusted = jTryBlock.body().decl(classes.KEY_STORE, "trusted"); - jVarTrusted.init(classes.KEY_STORE.staticInvoke("getInstance").arg("BKS")); - - } - - JVar jVarRes = null; - JVar jVarTrstFile = null; - JVar jVarKeyFile = null; - - if (useCustomKeyStore || useCustomTrustStore) { - jVarRes = jTryBlock.body().decl(classes.RESOURCES, "res", invoke("getResources")); - } - - IRInnerClass rInnerClass = rClass.get(Res.RAW); - if (useCustomKeyStore) { - JFieldRef rawIdRef = rInnerClass.getIdStaticRef(keyStoreRawId, holder); - JInvocation jInvRawKey = jVarRes.invoke("openRawResource").arg(rawIdRef); - jVarKeyFile = jTryBlock.body().decl(classes.INPUT_STREAM, "inKeystore", jInvRawKey); - } - - if (useCustomTrustStore) { - JFieldRef rawIdRef = rInnerClass.getIdStaticRef(trustStoreRawId, holder); - JInvocation jInvRawTrust = jVarRes.invoke("openRawResource").arg(rawIdRef); - jVarTrstFile = jTryBlock.body().decl(classes.INPUT_STREAM, "inTrustStore", jInvRawTrust); - - } else if (useCustomKeyStore) { - jVarTrstFile = jTryBlock.body().decl(classes.INPUT_STREAM, "inTrustStore", _new(classes.FILE_INPUT_STREAM).arg("/system/etc/security/cacerts.bks")); - } - - // try load - if (useCustomKeyStore || useCustomTrustStore) { - JTryBlock jTryLoad = jTryBlock.body()._try(); - - if (useCustomKeyStore) { - jTryLoad.body().add(invoke(jVarKeystore, "load").arg(jVarKeyFile).arg(invoke(lit(keyStorePwd), "toCharArray"))); - } - - if (useCustomTrustStore || !useCustomTrustStore && useCustomKeyStore) { - jTryLoad.body().add(invoke(jVarTrusted, "load").arg(jVarTrstFile).arg(invoke(lit(trustStorePwd), "toCharArray"))); - } - // finally load - JBlock jFinally = jTryLoad._finally(); - if (useCustomKeyStore) { - jFinally.add(invoke(jVarKeyFile, "close")); - } - - if (useCustomTrustStore || !useCustomTrustStore && useCustomKeyStore) { - jFinally.add(invoke(jVarTrstFile, "close")); - } - } - - if (null == jVarKeystore && null == jVarTrusted) { - JVar jVarCcm = jTryBlock.body().decl(classes.CLIENT_CONNECTION_MANAGER, "ccm"); - jVarCcm.init(_super().invoke("createClientConnectionManager")); - - if (allowAllHostnames) { - JExpression jCast = cast(classes.SSL_SOCKET_FACTORY, jVarCcm.invoke("getSchemeRegistry").invoke("getScheme").arg("https").invoke("getSocketFactory")); - jTryBlock.body().add(jCast.invoke("setHostnameVerifier").arg(classes.SSL_SOCKET_FACTORY.staticRef("ALLOW_ALL_HOSTNAME_VERIFIER"))); - } - - jTryBlock.body()._return(jVarCcm); - - } else { - JVar jVarSslFact = jTryBlock.body().decl(classes.SSL_SOCKET_FACTORY, "newSslSocketFactory"); - jVarSslFact.init(_new(classes.SSL_SOCKET_FACTORY).arg(null == jVarKeystore ? _null() : jVarKeystore).arg(keyStorePwd).arg(null == jVarTrusted ? _null() : jVarTrusted)); - - if (allowAllHostnames) { - jTryBlock.body().add(invoke(jVarSslFact, "setHostnameVerifier").arg(classes.SSL_SOCKET_FACTORY.staticRef("ALLOW_ALL_HOSTNAME_VERIFIER"))); - } - - JVar jVarSchemeReg = jTryBlock.body().decl(classes.SCHEME_REGISTRY, "registry"); - jVarSchemeReg.init(_new(classes.SCHEME_REGISTRY)); - jTryBlock.body().add(invoke(jVarSchemeReg, "register").arg(_new(classes.SCHEME).arg("https").arg(jVarSslFact).arg(lit(443)))); - - JVar jVarCcm = jTryBlock.body().decl(classes.CLIENT_CONNECTION_MANAGER, "ccm"); - jVarCcm.init(_new(classes.SINGLE_CLIENT_CONN_MANAGER).arg(invoke("getParams")).arg(jVarSchemeReg)); - jTryBlock.body()._return(jVarCcm); - } - - // catch block - JCatchBlock jCatchBlock = jTryBlock._catch(classes.EXCEPTION); - JVar jVarExceptionParam = jCatchBlock.param("e"); - jCatchBlock.body().add(jVarExceptionParam.invoke("printStackTrace")); - jCatchBlock.body()._return(_super().invoke("createClientConnectionManager")); - - methodBody.assign(ref(fieldName), _new(jAnonClass)); - - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/InstanceStateProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/InstanceStateProcessor.java deleted file mode 100644 index da6bfe8e69..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/InstanceStateProcessor.java +++ /dev/null @@ -1,166 +0,0 @@ -/** - * Copyright (C) 2010-2013 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._null; -import static com.sun.codemodel.JExpr.ref; -import static com.sun.codemodel.JMod.PRIVATE; -import static com.sun.codemodel.JMod.PUBLIC; -import static org.androidannotations.helper.CanonicalNameConstants.BUNDLE; -import static org.androidannotations.helper.CanonicalNameConstants.CHAR_SEQUENCE; -import static org.androidannotations.helper.CanonicalNameConstants.STRING; - -import java.util.HashMap; -import java.util.Map; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; - -import org.androidannotations.annotations.InstanceState; -import org.androidannotations.helper.APTCodeModelHelper; -import org.androidannotations.helper.AnnotationHelper; -import org.androidannotations.helper.BundleHelper; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -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.JVar; - -public class InstanceStateProcessor implements DecoratingElementProcessor { - - private static final String BUNDLE_PARAM_NAME = "bundle"; - - public static final Map methodSuffixNameByTypeName = new HashMap(); - - static { - - methodSuffixNameByTypeName.put(BUNDLE, "Bundle"); - - methodSuffixNameByTypeName.put("boolean", "Boolean"); - methodSuffixNameByTypeName.put("boolean[]", "BooleanArray"); - - methodSuffixNameByTypeName.put("byte", "Byte"); - methodSuffixNameByTypeName.put("byte[]", "ByteArray"); - - methodSuffixNameByTypeName.put("char", "Char"); - methodSuffixNameByTypeName.put("char[]", "CharArray"); - - methodSuffixNameByTypeName.put(CHAR_SEQUENCE, "CharSequence"); - - methodSuffixNameByTypeName.put("double", "Double"); - methodSuffixNameByTypeName.put("double[]", "DoubleArray"); - - methodSuffixNameByTypeName.put("float", "Float"); - methodSuffixNameByTypeName.put("float[]", "FloatArray"); - - methodSuffixNameByTypeName.put("int", "Int"); - methodSuffixNameByTypeName.put("int[]", "IntArray"); - methodSuffixNameByTypeName.put("java.util.ArrayList", "IntegerArrayList"); - - methodSuffixNameByTypeName.put("long", "Long"); - methodSuffixNameByTypeName.put("long[]", "LongArray"); - - methodSuffixNameByTypeName.put("short", "Short"); - methodSuffixNameByTypeName.put("short[]", "ShortArray"); - - methodSuffixNameByTypeName.put(STRING, "String"); - methodSuffixNameByTypeName.put("java.lang.String[]", "StringArray"); - methodSuffixNameByTypeName.put("java.util.ArrayList", "StringArrayList"); - } - - private final APTCodeModelHelper helper = new APTCodeModelHelper(); - - private AnnotationHelper annotationHelper; - - public InstanceStateProcessor(ProcessingEnvironment processingEnv) { - annotationHelper = new AnnotationHelper(processingEnv); - } - - @Override - public String getTarget() { - return InstanceState.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - String fieldName = element.getSimpleName().toString(); - - JBlock saveStateBody = getSaveStateMethodBody(codeModel, holder); - JBlock restoreStateBody = getRestoreStateBody(codeModel, holder); - - BundleHelper bundleHelper = new BundleHelper(annotationHelper, element); - - JFieldRef ref = ref(fieldName); - saveStateBody.invoke(ref(BUNDLE_PARAM_NAME), bundleHelper.getMethodNameToSave()).arg(fieldName).arg(ref); - - JInvocation restoreMethodCall = JExpr.invoke(ref("savedInstanceState"), bundleHelper.getMethodNameToRestore()).arg(fieldName); - if (bundleHelper.restoreCallNeedCastStatement()) { - - JClass jclass = helper.typeMirrorToJClass(element.asType(), holder); - JExpression castStatement = JExpr.cast(jclass, restoreMethodCall); - restoreStateBody.assign(ref, castStatement); - - if (bundleHelper.restoreCallNeedsSuppressWarning()) { - if (holder.restoreSavedInstanceStateMethod.annotations().size() == 0) { - holder.restoreSavedInstanceStateMethod.annotate(SuppressWarnings.class).param("value", "unchecked"); - } - } - - } else { - restoreStateBody.assign(ref, restoreMethodCall); - } - } - - private JBlock getRestoreStateBody(JCodeModel codeModel, EBeanHolder holder) { - - if (holder.restoreSavedInstanceStateMethod == null) { - - holder.restoreSavedInstanceStateMethod = holder.generatedClass.method(PRIVATE, codeModel.VOID, "restoreSavedInstanceState_"); - - JVar savedInstanceState = holder.restoreSavedInstanceStateMethod.param(holder.classes().BUNDLE, "savedInstanceState"); - - holder.initIfActivityBody.invoke(holder.restoreSavedInstanceStateMethod).arg(savedInstanceState); - - holder.restoreSavedInstanceStateMethod.body() // - ._if(ref("savedInstanceState").eq(_null())) // - ._then()._return(); - - } - - return holder.restoreSavedInstanceStateMethod.body(); - } - - private JBlock getSaveStateMethodBody(JCodeModel codeModel, EBeanHolder holder) { - - if (holder.saveInstanceStateBlock == null) { - JMethod method = holder.generatedClass.method(PUBLIC, codeModel.VOID, "onSaveInstanceState"); - method.annotate(Override.class); - method.param(holder.classes().BUNDLE, BUNDLE_PARAM_NAME); - - holder.saveInstanceStateBlock = method.body(); - - holder.saveInstanceStateBlock.invoke(JExpr._super(), "onSaveInstanceState").arg(JExpr.ref(BUNDLE_PARAM_NAME)); - } - - return holder.saveInstanceStateBlock; - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ItemClickProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ItemClickProcessor.java deleted file mode 100644 index 4968155ddc..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ItemClickProcessor.java +++ /dev/null @@ -1,107 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.cast; -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.TypeKind; -import javax.lang.model.type.TypeMirror; - -import org.androidannotations.annotations.ItemClick; -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.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; - -public class ItemClickProcessor implements DecoratingElementProcessor { - - private IdAnnotationHelper helper; - - public ItemClickProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - helper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - } - - @Override - public String getTarget() { - return ItemClick.class.getName(); - } - - @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 hasItemParameter = parameters.size() == 1; - - List idsRefs = helper.extractAnnotationFieldRefs(holder, element, Res.ID, true); - - JDefinedClass onItemClickListenerAnonymousClass = codeModel.anonymousClass(classes.ON_ITEM_CLICK_LISTENER); - JMethod onItemClickMethod = onItemClickListenerAnonymousClass.method(JMod.PUBLIC, codeModel.VOID, "onItemClick"); - onItemClickMethod.annotate(Override.class); - - JClass narrowAdapterViewClass = classes.ADAPTER_VIEW.narrow(codeModel.wildcard()); - JVar onItemClickParentParam = onItemClickMethod.param(narrowAdapterViewClass, "parent"); - onItemClickMethod.param(classes.VIEW, "view"); - JVar onItemClickPositionParam = onItemClickMethod.param(codeModel.INT, "position"); - onItemClickMethod.param(codeModel.LONG, "id"); - - JInvocation itemClickCall = onItemClickMethod.body().invoke(methodName); - - if (hasItemParameter) { - VariableElement parameter = parameters.get(0); - - TypeMirror parameterType = parameter.asType(); - if (parameterType.getKind() == TypeKind.INT) { - itemClickCall.arg(onItemClickPositionParam); - } else { - String parameterTypeQualifiedName = parameterType.toString(); - itemClickCall.arg(cast(holder.refClass(parameterTypeQualifiedName), invoke(onItemClickParentParam, "getAdapter").invoke("getItem").arg(onItemClickPositionParam))); - } - } - - ViewChangedHolder onViewChanged = holder.onViewChanged(); - for (JFieldRef idRef : idsRefs) { - JBlock block = onViewChanged.body().block(); - - JVar view = block.decl(narrowAdapterViewClass, "view", cast(narrowAdapterViewClass, onViewChanged.findViewById(idRef))); - block._if(view.ne(JExpr._null()))._then().invoke(view, "setOnItemClickListener").arg(_new(onItemClickListenerAnonymousClass)); - } - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ItemLongClickProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ItemLongClickProcessor.java deleted file mode 100644 index b7fbb9108d..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ItemLongClickProcessor.java +++ /dev/null @@ -1,118 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.cast; -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.TypeKind; -import javax.lang.model.type.TypeMirror; - -import org.androidannotations.annotations.ItemLongClick; -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.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; - -public class ItemLongClickProcessor implements DecoratingElementProcessor { - - private IdAnnotationHelper helper; - - public ItemLongClickProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - helper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - } - - @Override - public String getTarget() { - return ItemLongClick.class.getName(); - } - - @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(); - boolean returnMethodResult = returnType.getKind() != TypeKind.VOID; - - boolean hasItemParameter = parameters.size() == 1; - - List idsRefs = helper.extractAnnotationFieldRefs(holder, element, Res.ID, true); - - JDefinedClass onItemLongClickListenerClass = codeModel.anonymousClass(classes.ON_ITEM_LONG_CLICK_LISTENER); - JMethod onItemLongClickMethod = onItemLongClickListenerClass.method(JMod.PUBLIC, codeModel.BOOLEAN, "onItemLongClick"); - onItemLongClickMethod.annotate(Override.class); - - JClass narrowAdapterViewClass = classes.ADAPTER_VIEW.narrow(codeModel.wildcard()); - JVar onItemClickParentParam = onItemLongClickMethod.param(narrowAdapterViewClass, "parent"); - onItemLongClickMethod.param(classes.VIEW, "view"); - JVar onItemClickPositionParam = onItemLongClickMethod.param(codeModel.INT, "position"); - onItemLongClickMethod.param(codeModel.LONG, "id"); - - JBlock onItemLongClickBody = onItemLongClickMethod.body(); - - JInvocation itemClickCall = JExpr.invoke(methodName); - - if (returnMethodResult) { - onItemLongClickBody._return(itemClickCall); - } else { - onItemLongClickBody.add(itemClickCall); - onItemLongClickBody._return(JExpr.TRUE); - } - - if (hasItemParameter) { - VariableElement parameter = parameters.get(0); - - TypeMirror parameterType = parameter.asType(); - if (parameterType.getKind() == TypeKind.INT) { - itemClickCall.arg(onItemClickPositionParam); - } else { - String parameterTypeQualifiedName = parameterType.toString(); - itemClickCall.arg(cast(holder.refClass(parameterTypeQualifiedName), invoke(onItemClickParentParam, "getAdapter").invoke("getItem").arg(onItemClickPositionParam))); - } - } - - ViewChangedHolder onViewChanged = holder.onViewChanged(); - for (JFieldRef idRef : idsRefs) { - JBlock block = onViewChanged.body().block(); - JVar view = block.decl(narrowAdapterViewClass, "view", cast(narrowAdapterViewClass, onViewChanged.findViewById(idRef))); - block._if(view.ne(_null()))._then().invoke(view, "setOnItemLongClickListener").arg(_new(onItemLongClickListenerClass)); - } - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ItemSelectedProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ItemSelectedProcessor.java deleted file mode 100644 index 2ec8a65195..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ItemSelectedProcessor.java +++ /dev/null @@ -1,132 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.cast; -import static com.sun.codemodel.JExpr.invoke; -import static com.sun.codemodel.JExpr.lit; - -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.ItemSelect; -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.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; - -/** - */ -public class ItemSelectedProcessor implements DecoratingElementProcessor { - - private IdAnnotationHelper helper; - - public ItemSelectedProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - helper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - } - - @Override - public String getTarget() { - return ItemSelect.class.getName(); - } - - @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(); - - List idsRefs = helper.extractAnnotationFieldRefs(holder, element, Res.ID, true); - - JDefinedClass onItemSelectedListenerClass = codeModel.anonymousClass(classes.ON_ITEM_SELECTED_LISTENER); - JMethod onItemSelectedMethod = onItemSelectedListenerClass.method(JMod.PUBLIC, codeModel.VOID, "onItemSelected"); - onItemSelectedMethod.annotate(Override.class); - - JClass narrowAdapterViewClass = classes.ADAPTER_VIEW.narrow(codeModel.wildcard()); - JVar onItemClickParentParam = onItemSelectedMethod.param(narrowAdapterViewClass, "parent"); - onItemSelectedMethod.param(classes.VIEW, "view"); - JVar onItemClickPositionParam = onItemSelectedMethod.param(codeModel.INT, "position"); - onItemSelectedMethod.param(codeModel.LONG, "id"); - - JInvocation itemSelectedCall = onItemSelectedMethod.body().invoke(methodName); - - itemSelectedCall.arg(JExpr.TRUE); - - boolean hasItemParameter = parameters.size() == 2; - boolean secondParameterIsInt = false; - String secondParameterQualifiedName = null; - if (hasItemParameter) { - VariableElement secondParameter = parameters.get(1); - TypeMirror secondParameterType = secondParameter.asType(); - secondParameterQualifiedName = secondParameterType.toString(); - secondParameterIsInt = secondParameterType.getKind() == TypeKind.INT; - } - - if (hasItemParameter) { - - if (secondParameterIsInt) { - itemSelectedCall.arg(onItemClickPositionParam); - } else { - itemSelectedCall.arg(JExpr.cast(holder.refClass(secondParameterQualifiedName), invoke(onItemClickParentParam, "getAdapter").invoke("getItem").arg(onItemClickPositionParam))); - } - } - - JMethod onNothingSelectedMethod = onItemSelectedListenerClass.method(JMod.PUBLIC, codeModel.VOID, "onNothingSelected"); - onNothingSelectedMethod.annotate(Override.class); - - onNothingSelectedMethod.param(narrowAdapterViewClass, "parent"); - - JInvocation nothingSelectedCall = onNothingSelectedMethod.body().invoke(methodName); - - nothingSelectedCall.arg(JExpr.FALSE); - if (hasItemParameter) { - if (secondParameterIsInt) { - nothingSelectedCall.arg(lit(-1)); - } else { - nothingSelectedCall.arg(_null()); - } - } - - ViewChangedHolder onViewChanged = holder.onViewChanged(); - for (JFieldRef idRef : idsRefs) { - JBlock body = onViewChanged.body(); - body.add(invoke(cast(narrowAdapterViewClass, onViewChanged.findViewById(idRef)), "setOnItemSelectedListener").arg(_new(onItemSelectedListenerClass))); - } - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/LongClickProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/LongClickProcessor.java deleted file mode 100644 index 66e1a23bbd..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/LongClickProcessor.java +++ /dev/null @@ -1,83 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.TypeKind; -import javax.lang.model.type.TypeMirror; - -import org.androidannotations.annotations.LongClick; -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.JInvocation; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JMod; -import com.sun.codemodel.JVar; - -public class LongClickProcessor extends AbstractListenerProcessor { - - public LongClickProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - super(processingEnv, rClass); - } - - @Override - public String getTarget() { - return LongClick.class.getName(); - } - - @Override - protected void makeCall(JBlock listenerMethodBody, JInvocation call, TypeMirror returnType) { - boolean returnMethodResult = returnType.getKind() != TypeKind.VOID; - if (returnMethodResult) { - listenerMethodBody._return(call); - } else { - listenerMethodBody.add(call); - listenerMethodBody._return(JExpr.TRUE); - } - } - - @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"); - } - - @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/ModelProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ModelProcessor.java deleted file mode 100644 index 7e70c22d0f..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ModelProcessor.java +++ /dev/null @@ -1,144 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.ArrayList; -import java.util.List; -import java.util.Set; - -import javax.lang.model.element.Element; -import javax.lang.model.element.ElementKind; -import javax.lang.model.element.Modifier; -import javax.lang.model.element.TypeElement; - -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.model.AnnotationElements.AnnotatedAndRootElements; - -import com.sun.codemodel.JCodeModel; - -public class ModelProcessor { - - public static class ProcessResult { - - public final JCodeModel codeModel; - public final OriginatingElements originatingElements; - public final Set> apiClassesToGenerate; - - public ProcessResult(// - JCodeModel codeModel, // - OriginatingElements originatingElements, // - Set> apiClassesToGenerate) { - - this.codeModel = codeModel; - this.originatingElements = originatingElements; - this.apiClassesToGenerate = apiClassesToGenerate; - } - } - - private final List enclosedProcessors = new ArrayList(); - private final List typeProcessors = new ArrayList(); - - public void register(DecoratingElementProcessor processor) { - enclosedProcessors.add(processor); - } - - public void register(GeneratingElementProcessor processor) { - typeProcessors.add(processor); - } - - public ProcessResult process(AnnotationElements validatedModel) throws Exception { - - JCodeModel codeModel = new JCodeModel(); - - EBeansHolder eBeansHolder = new EBeansHolder(codeModel); - - for (GeneratingElementProcessor processor : typeProcessors) { - String annotationName = processor.getTarget(); - Set annotatedElements = validatedModel.getRootAnnotatedElements(annotationName); - for (Element annotatedElement : annotatedElements) { - /* - * We do not generate code for abstract classes, because the - * generated classes are final anyway (we do not want anyone to - * extend them). - */ - if (!isAbstractClass(annotatedElement)) { - processor.process(annotatedElement, codeModel, eBeansHolder); - } - } - /* - * We currently do not take into account class annotations from - * ancestors. We should careful design the priority rules first. - */ - } - - for (DecoratingElementProcessor processor : enclosedProcessors) { - String annotationName = processor.getTarget(); - - /* - * For ancestors, the processor manipulates the annotated elements, - * but uses the holder for the root element - */ - Set ancestorAnnotatedElements = validatedModel.getAncestorAnnotatedElements(annotationName); - for (AnnotatedAndRootElements elements : ancestorAnnotatedElements) { - EBeanHolder holder = eBeansHolder.getEBeanHolder(elements.rootTypeElement); - /* - * Annotations coming from ancestors may be applied to root - * elements that are not validated, and therefore not available. - */ - if (holder != null) { - processor.process(elements.annotatedElement, codeModel, holder); - } - } - - Set rootAnnotatedElements = validatedModel.getRootAnnotatedElements(annotationName); - - for (Element annotatedElement : rootAnnotatedElements) { - - Element enclosingElement; - if (annotatedElement instanceof TypeElement) { - enclosingElement = annotatedElement; - } else { - enclosingElement = annotatedElement.getEnclosingElement(); - } - - /* - * We do not generate code for elements belonging to abstract - * classes, because the generated classes are final anyway - */ - if (!isAbstractClass(enclosingElement)) { - EBeanHolder holder = eBeansHolder.getEBeanHolder(enclosingElement); - processor.process(annotatedElement, codeModel, holder); - } - } - - } - - return new ProcessResult(// - codeModel, // - eBeansHolder.getOriginatingElements(), // - eBeansHolder.getApiClassesToGenerate()); - } - - private boolean isAbstractClass(Element annotatedElement) { - if (annotatedElement instanceof TypeElement) { - TypeElement typeElement = (TypeElement) annotatedElement; - - return typeElement.getKind() == ElementKind.CLASS && typeElement.getModifiers().contains(Modifier.ABSTRACT); - } else { - return false; - } - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/NoTitleProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/NoTitleProcessor.java deleted file mode 100644 index d31731bf0e..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/NoTitleProcessor.java +++ /dev/null @@ -1,40 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 javax.lang.model.element.Element; - -import org.androidannotations.annotations.NoTitle; - -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JFieldRef; - -public class NoTitleProcessor implements DecoratingElementProcessor { - - @Override - public String getTarget() { - return NoTitle.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - - JFieldRef noTitle = holder.classes().WINDOW.staticRef("FEATURE_NO_TITLE"); - - holder.initBody.invoke("requestWindowFeature").arg(noTitle); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/NonConfigurationHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/NonConfigurationHolder.java deleted file mode 100644 index 99c16a072b..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/NonConfigurationHolder.java +++ /dev/null @@ -1,36 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 com.sun.codemodel.JBlock; -import com.sun.codemodel.JDefinedClass; -import com.sun.codemodel.JInvocation; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JVar; - -public class NonConfigurationHolder { - - public JDefinedClass holderClass; - - public JMethod holderConstructor; - - public JInvocation newHolder; - - public JBlock initIfNonConfigurationNotNullBody; - - public JVar initNonConfigurationInstance; - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/NonConfigurationInstanceProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/NonConfigurationInstanceProcessor.java deleted file mode 100644 index 2ca522f65e..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/NonConfigurationInstanceProcessor.java +++ /dev/null @@ -1,159 +0,0 @@ -/** - * Copyright (C) 2010-2013 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._super; -import static com.sun.codemodel.JExpr._this; -import static com.sun.codemodel.JExpr.cast; -import static com.sun.codemodel.JMod.FINAL; -import static com.sun.codemodel.JMod.PUBLIC; -import static org.androidannotations.helper.ModelConstants.GENERATION_SUFFIX; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; -import javax.lang.model.type.DeclaredType; -import javax.lang.model.type.TypeMirror; - -import org.androidannotations.annotations.Bean; -import org.androidannotations.annotations.NonConfigurationInstance; -import org.androidannotations.helper.APTCodeModelHelper; -import org.androidannotations.helper.AnnotationHelper; -import org.androidannotations.helper.CanonicalNameConstants; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JClassAlreadyExistsException; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JFieldVar; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JMod; -import com.sun.codemodel.JVar; - -public class NonConfigurationInstanceProcessor implements DecoratingElementProcessor { - - private APTCodeModelHelper aptCodeModelHelper; - private AnnotationHelper annotationHelper; - - public NonConfigurationInstanceProcessor(ProcessingEnvironment processingEnv) { - annotationHelper = new AnnotationHelper(processingEnv); - aptCodeModelHelper = new APTCodeModelHelper(); - } - - @Override - public String getTarget() { - return NonConfigurationInstance.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) throws JClassAlreadyExistsException { - - NonConfigurationHolder ncHolder = holder.nonConfigurationHolder; - - if (ncHolder == null) { - - ncHolder = new NonConfigurationHolder(); - holder.nonConfigurationHolder = ncHolder; - - ncHolder.holderClass = holder.generatedClass._class(JMod.PRIVATE | JMod.STATIC, "NonConfigurationInstancesHolder"); - - JFieldVar superNonConfigurationInstanceField = ncHolder.holderClass.field(PUBLIC | FINAL, Object.class, "superNonConfigurationInstance"); - - ncHolder.holderConstructor = ncHolder.holderClass.constructor(PUBLIC); - - JVar superNonConfigurationInstanceParam = ncHolder.holderConstructor.param(Object.class, "superNonConfigurationInstance"); - - ncHolder.holderConstructor.body() // - .assign(_this().ref(superNonConfigurationInstanceField), superNonConfigurationInstanceParam); - - TypeElement fragmentActivityTypeElement = annotationHelper.typeElementFromQualifiedName(CanonicalNameConstants.FRAGMENT_ACTIVITY); - TypeElement typeElement = annotationHelper.typeElementFromQualifiedName(holder.generatedClass._extends().fullName()); - - String getLastNonConfigurationInstanceName = "getLastNonConfigurationInstance"; - String onRetainNonConfigurationInstanceName = "onRetainNonConfigurationInstance"; - if (fragmentActivityTypeElement != null && annotationHelper.isSubtype(typeElement.asType(), fragmentActivityTypeElement.asType())) { - getLastNonConfigurationInstanceName = "getLastCustomNonConfigurationInstance"; - onRetainNonConfigurationInstanceName = "onRetainCustomNonConfigurationInstance"; - } - - { - // init() - JBlock initBody = holder.initBody; - ncHolder.initNonConfigurationInstance = initBody.decl(ncHolder.holderClass, "nonConfigurationInstance", cast(ncHolder.holderClass, _super().invoke(getLastNonConfigurationInstanceName))); - ncHolder.initIfNonConfigurationNotNullBody = initBody._if(ncHolder.initNonConfigurationInstance.ne(_null()))._then(); - } - - { - // getLastNonConfigurationInstance() - JMethod getLastNonConfigurationInstance = holder.generatedClass.method(PUBLIC, Object.class, getLastNonConfigurationInstanceName); - - getLastNonConfigurationInstance.annotate(Override.class); - JBlock body = getLastNonConfigurationInstance.body(); - - JVar nonConfigurationInstance = body.decl(ncHolder.holderClass, "nonConfigurationInstance", cast(ncHolder.holderClass, _super().invoke(getLastNonConfigurationInstance))); - - body._if(nonConfigurationInstance.eq(_null()))._then()._return(_null()); - - body._return(nonConfigurationInstance.ref(superNonConfigurationInstanceField)); - } - - { - // onRetainNonConfigurationInstance() - JMethod onRetainNonConfigurationInstance = holder.generatedClass.method(PUBLIC, ncHolder.holderClass, onRetainNonConfigurationInstanceName); - - onRetainNonConfigurationInstance.annotate(Override.class); - ncHolder.newHolder = _new(ncHolder.holderClass); - ncHolder.newHolder.arg(_super().invoke(onRetainNonConfigurationInstance)); - onRetainNonConfigurationInstance.body()._return(ncHolder.newHolder); - } - } - - String fieldName = element.getSimpleName().toString(); - JClass fieldType = aptCodeModelHelper.typeMirrorToJClass(element.asType(), holder); - JFieldVar field = ncHolder.holderClass.field(PUBLIC | FINAL, fieldType, fieldName); - - JVar constructorParam = ncHolder.holderConstructor.param(fieldType, fieldName); - - ncHolder.holderConstructor.body() // - .assign(_this().ref(field), constructorParam); - - ncHolder.newHolder.arg(field); - - ncHolder.initIfNonConfigurationNotNullBody.assign(field, ncHolder.initNonConfigurationInstance.ref(field)); - - boolean hasBeanAnnotation = element.getAnnotation(Bean.class) != null; - if (hasBeanAnnotation) { - - DeclaredType targetAnnotationClassValue = annotationHelper.extractAnnotationClassParameter(element, Bean.class.getName()); - - TypeMirror elementType; - if (targetAnnotationClassValue != null) { - elementType = targetAnnotationClassValue; - } else { - elementType = element.asType(); - } - - String typeQualifiedName = elementType.toString(); - - JClass fieldGeneratedBeanClass = holder.refClass(typeQualifiedName + GENERATION_SUFFIX); - - ncHolder.initIfNonConfigurationNotNullBody.invoke(cast(fieldGeneratedBeanClass, field), "rebind").arg(_this()); - } - - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OnActivityResultProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OnActivityResultProcessor.java deleted file mode 100644 index 843809d696..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OnActivityResultProcessor.java +++ /dev/null @@ -1,138 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.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.OnActivityResult; -import org.androidannotations.helper.APTCodeModelHelper; -import org.androidannotations.helper.CanonicalNameConstants; -import org.androidannotations.rclass.IRClass; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JCase; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -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.JSwitch; -import com.sun.codemodel.JVar; - -/** - */ -public class OnActivityResultProcessor implements DecoratingElementProcessor { - - private APTCodeModelHelper codeModelHelper; - - public OnActivityResultProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - codeModelHelper = new APTCodeModelHelper(); - } - - @Override - public String getTarget() { - return OnActivityResult.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - - String methodName = element.getSimpleName().toString(); - - ExecutableElement executableElement = (ExecutableElement) element; - List parameters = executableElement.getParameters(); - - int intentParameterPosition = -1; - int resultCodeParameterPosition = -1; - - for (int i = 0; i < parameters.size(); i++) { - VariableElement parameter = parameters.get(i); - TypeMirror parameterType = parameter.asType(); - - if (CanonicalNameConstants.INTENT.equals(parameterType.toString())) { - intentParameterPosition = i; - } else if (parameterType.getKind().equals(TypeKind.INT) // - || CanonicalNameConstants.INTEGER.equals(parameterType.toString())) { - resultCodeParameterPosition = i; - } - - } - - int requestCode = executableElement.getAnnotation(OnActivityResult.class).value(); - - JBlock onActivityResultCase = getOrCreateOnActivityResultMethodBody(codeModel, holder, requestCode); - - JExpression activityRef = holder.generatedClass.staticRef("this"); - JInvocation onResultInvocation = onActivityResultCase.invoke(activityRef, methodName); - - for (int i = 0; i < parameters.size(); i++) { - if (i == intentParameterPosition) { - JVar intentParameter = codeModelHelper.findParameterByName(holder.onActivityResultMethod, "data"); - onResultInvocation.arg(intentParameter); - } else if (i == resultCodeParameterPosition) { - JVar resultCodeParameter = codeModelHelper.findParameterByName(holder.onActivityResultMethod, "resultCode"); - onResultInvocation.arg(resultCodeParameter); - } - } - - } - - public JBlock getOrCreateOnActivityResultMethodBody(JCodeModel codeModel, EBeanHolder holder, int requestCode) { - JClass intentClass = holder.classes().INTENT; - - if (holder.onActivityResultSwitch == null) { - - JMethod onActivityResultMethod = holder.generatedClass.method(JMod.PUBLIC, codeModel.VOID, "onActivityResult"); - JVar requestCodeParam = onActivityResultMethod.param(codeModel.INT, "requestCode"); - onActivityResultMethod.param(codeModel.INT, "resultCode"); - onActivityResultMethod.param(intentClass, "data"); - onActivityResultMethod.annotate(Override.class); - - holder.onActivityResultMethod = onActivityResultMethod; - - JBlock onActivityResultMethodBody = onActivityResultMethod.body(); - codeModelHelper.callSuperMethod(onActivityResultMethod, holder, onActivityResultMethodBody); - holder.onActivityResultSwitch = onActivityResultMethodBody._switch(requestCodeParam); - } - - JSwitch onActivityResultSwitch = holder.onActivityResultSwitch; - - JBlock onActivityResultCaseBlock = holder.onActivityResultCases.get(requestCode); - - if (onActivityResultCaseBlock == null) { - - JCase onActivityResultCase = onActivityResultSwitch._case(JExpr.lit(requestCode)); - - onActivityResultCaseBlock = onActivityResultCase.body().block(); - - onActivityResultCase.body()._break(); - - holder.onActivityResultCases.put(requestCode, onActivityResultCaseBlock); - - } - - return onActivityResultCaseBlock; - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OnSeekBarChangeListenerHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OnSeekBarChangeListenerHolder.java deleted file mode 100644 index ca719ab5ea..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OnSeekBarChangeListenerHolder.java +++ /dev/null @@ -1,44 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 com.sun.codemodel.JMethod; -import com.sun.codemodel.JVar; - -public class OnSeekBarChangeListenerHolder { - - final JMethod onStartTrackingTouchMethod; - - final JMethod onProgressChangedMethod; - - final JMethod onStopTrackingTouchMethod; - - final JVar viewVariable; - - public OnSeekBarChangeListenerHolder(// - JMethod onStartTrackingTouchMethod, // - JMethod onProgressChangedMethod, // - JMethod onStopTrackingTouchMethod, // - JVar viewVariable) { - - this.onStartTrackingTouchMethod = onStartTrackingTouchMethod; - this.onProgressChangedMethod = onProgressChangedMethod; - this.onStopTrackingTouchMethod = onStopTrackingTouchMethod; - this.viewVariable = viewVariable; - - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OptionsItemProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OptionsItemProcessor.java deleted file mode 100644 index 080a57a512..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OptionsItemProcessor.java +++ /dev/null @@ -1,127 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.FALSE; -import static com.sun.codemodel.JExpr.TRUE; -import static com.sun.codemodel.JExpr._super; -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.TypeKind; -import javax.lang.model.type.TypeMirror; - -import org.androidannotations.annotations.OptionsItem; -import org.androidannotations.helper.IdAnnotationHelper; -import org.androidannotations.helper.ThirdPartyLibHelper; -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.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 OptionsItemProcessor implements DecoratingElementProcessor { - - private final IdAnnotationHelper helper; - - private final ThirdPartyLibHelper libHelper; - - public OptionsItemProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - helper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - libHelper = new ThirdPartyLibHelper(helper); - } - - @Override - public String getTarget() { - return OptionsItem.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - Classes classes = holder.classes(); - - String methodName = element.getSimpleName().toString(); - - JClass menuItemClass; - if (libHelper.usesActionBarSherlock(holder)) { - menuItemClass = classes.SHERLOCK_MENU_ITEM; - } else { - menuItemClass = classes.MENU_ITEM; - } - - ExecutableElement executableElement = (ExecutableElement) element; - List parameters = executableElement.getParameters(); - TypeMirror returnType = executableElement.getReturnType(); - boolean returnMethodResult = returnType.getKind() != TypeKind.VOID; - - boolean hasItemParameter = parameters.size() == 1; - - List idsRefs = helper.extractAnnotationFieldRefs(holder, element, Res.ID, true); - - if (holder.onOptionsItemSelectedIfElseBlock == null) { - JMethod method = holder.generatedClass.method(JMod.PUBLIC, codeModel.BOOLEAN, "onOptionsItemSelected"); - method.annotate(Override.class); - holder.onOptionsItemSelectedItem = method.param(menuItemClass, "item"); - - JBlock body = method.body(); - JVar handled = body.decl(codeModel.BOOLEAN, "handled", invoke(_super(), method).arg(holder.onOptionsItemSelectedItem)); - - body._if(handled)._then()._return(TRUE); - - holder.onOptionsItemSelectedItemId = body.decl(codeModel.INT, "itemId_", holder.onOptionsItemSelectedItem.invoke("getItemId")); - holder.onOptionsItemSelectedIfElseBlock = body.block(); - - body._return(FALSE); - } - - JExpression ifExpr = holder.onOptionsItemSelectedItemId.eq(idsRefs.get(0)); - - for (int i = 1; i < idsRefs.size(); i++) { - ifExpr = ifExpr.cor(holder.onOptionsItemSelectedItemId.eq(idsRefs.get(i))); - } - - JBlock itemIfBody = holder.onOptionsItemSelectedIfElseBlock._if(ifExpr)._then(); - JInvocation methodCall = invoke(methodName); - - if (returnMethodResult) { - itemIfBody._return(methodCall); - } else { - itemIfBody.add(methodCall); - itemIfBody._return(TRUE); - } - - if (hasItemParameter) { - methodCall.arg(holder.onOptionsItemSelectedItem); - } - - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OptionsMenuItemProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OptionsMenuItemProcessor.java deleted file mode 100644 index b99ab88561..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OptionsMenuItemProcessor.java +++ /dev/null @@ -1,58 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.ref; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; - -import org.androidannotations.annotations.OptionsMenuItem; -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.JFieldRef; -import com.sun.codemodel.JVar; - -/** - */ -public class OptionsMenuItemProcessor extends AbstractOptionsMenuProcessor { - - public OptionsMenuItemProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - super(processingEnv, rClass); - } - - @Override - public String getTarget() { - return OptionsMenuItem.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - super.process(element, codeModel, holder); - - String fieldName = element.getSimpleName().toString(); - JBlock body = holder.onCreateOptionMenuMethodBody; - JVar menuParam = holder.onCreateOptionMenuMenuParam; - - JFieldRef idsRef = annotationHelper.extractOneAnnotationFieldRef(holder, element, Res.ID, true); - - body.assign(ref(fieldName), menuParam.invoke("findItem").arg(idsRef)); - - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OptionsMenuProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OptionsMenuProcessor.java deleted file mode 100644 index 4234a22ac8..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OptionsMenuProcessor.java +++ /dev/null @@ -1,58 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.Element; - -import org.androidannotations.annotations.OptionsMenu; -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.JFieldRef; -import com.sun.codemodel.JVar; - -public class OptionsMenuProcessor extends AbstractOptionsMenuProcessor { - - public OptionsMenuProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - super(processingEnv, rClass); - } - - @Override - public String getTarget() { - return OptionsMenu.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - super.process(element, codeModel, holder); - - JBlock body = holder.onCreateOptionMenuMethodBody; - JVar menuInflater = holder.onCreateOptionMenuMenuInflaterVariable; - JVar menuParam = holder.onCreateOptionMenuMenuParam; - - List fieldRefs = annotationHelper.extractAnnotationFieldRefs(holder, element, Res.MENU, false); - - for (JFieldRef optionsMenuRefId : fieldRefs) { - body.invoke(menuInflater, "inflate").arg(optionsMenuRefId).arg(menuParam); - } - - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OrmLiteDaoProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OrmLiteDaoProcessor.java deleted file mode 100644 index bb87480891..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/OrmLiteDaoProcessor.java +++ /dev/null @@ -1,102 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.ref; -import static com.sun.codemodel.JMod.PRIVATE; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.type.TypeMirror; - -import org.androidannotations.annotations.OrmLiteDao; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.processing.EBeansHolder.Classes; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JCatchBlock; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JExpression; -import com.sun.codemodel.JFieldVar; -import com.sun.codemodel.JTryBlock; -import com.sun.codemodel.JVar; - -/** - * This class generates the code that creates DAOs with ORMLite - */ -public class OrmLiteDaoProcessor implements DecoratingElementProcessor { - - private static final String DATABASE_HELPER_FIELD_NAME = "helper_"; - private TargetAnnotationHelper helper; - - public OrmLiteDaoProcessor(ProcessingEnvironment processingEnv) { - helper = new TargetAnnotationHelper(processingEnv, getTarget()); - } - - @Override - public String getTarget() { - return OrmLiteDao.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - Classes classes = holder.classes(); - - String fieldName = element.getSimpleName().toString(); - - TypeMirror modelObjectTypeMirror = helper.extractAnnotationParameter(element, "model"); - - TypeMirror databaseHelperTypeMirror = helper.extractAnnotationParameter(element, "helper"); - - // database helper field - boolean databaseHelperInjected = holder.generatedClass.fields().containsKey(DATABASE_HELPER_FIELD_NAME); - - JBlock initBody = holder.initBody; - - JFieldVar databaseHelperRef; - if (databaseHelperInjected) { - databaseHelperRef = holder.generatedClass.fields().get(DATABASE_HELPER_FIELD_NAME); - } else { - databaseHelperRef = holder.generatedClass.field(PRIVATE, holder.refClass(databaseHelperTypeMirror.toString()), DATABASE_HELPER_FIELD_NAME); - - // get database helper instance - JExpression dbHelperClass = holder.refClass(databaseHelperTypeMirror.toString()).dotclass(); - - initBody.assign(databaseHelperRef, // - classes.OPEN_HELPER_MANAGER // - .staticInvoke("getHelper") // - .arg(holder.contextRef) // - .arg(dbHelperClass)); - } - - // create dao from database helper - JTryBlock tryBlock = initBody._try(); - - JExpression modelClass = holder.refClass(modelObjectTypeMirror.toString()).dotclass(); - tryBlock.body().assign(ref(fieldName), // - databaseHelperRef.invoke("getDao"). // - arg(modelClass)); - - JCatchBlock catchBlock = tryBlock._catch(classes.SQL_EXCEPTION); - JVar exception = catchBlock.param("e"); - - catchBlock.body() // - .staticInvoke(classes.LOG, "e") // - .arg(holder.generatedClass.name()) // - .arg("Could not create DAO " + fieldName) // - .arg(exception); - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/PrefProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/PrefProcessor.java deleted file mode 100644 index 4b972cfad5..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/PrefProcessor.java +++ /dev/null @@ -1,84 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.helper.ModelConstants.GENERATION_SUFFIX; - -import java.util.Set; - -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; -import javax.lang.model.type.ErrorType; -import javax.lang.model.type.TypeKind; -import javax.lang.model.type.TypeMirror; - -import org.androidannotations.annotations.sharedpreferences.Pref; -import org.androidannotations.annotations.sharedpreferences.SharedPref; -import org.androidannotations.model.AnnotationElements; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JFieldRef; - -public class PrefProcessor implements DecoratingElementProcessor { - - private final AnnotationElements validatedModel; - - public PrefProcessor(AnnotationElements validatedModel) { - this.validatedModel = validatedModel; - } - - @Override - public String getTarget() { - return Pref.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - - String fieldName = element.getSimpleName().toString(); - - TypeMirror fieldTypeMirror = element.asType(); - - String fieldType = fieldTypeMirror.toString(); - if (fieldTypeMirror instanceof ErrorType || fieldTypeMirror.getKind() == TypeKind.ERROR) { - String elementTypeName = fieldTypeMirror.toString(); - String prefTypeName = elementTypeName.substring(0, elementTypeName.length() - GENERATION_SUFFIX.length()); - Set sharedPrefElements = validatedModel.getRootAnnotatedElements(SharedPref.class.getName()); - - for (Element sharedPrefElement : sharedPrefElements) { - TypeElement sharedPrefTypeElement = (TypeElement) sharedPrefElement; - - String sharedPrefSimpleName = sharedPrefTypeElement.getSimpleName().toString(); - String sharedPrefQualifiedName = sharedPrefTypeElement.getQualifiedName().toString(); - - if (sharedPrefSimpleName.equals(prefTypeName)) { - fieldType = sharedPrefQualifiedName + GENERATION_SUFFIX; - break; - } - } - - } - - JBlock methodBody = holder.initBody; - - JFieldRef field = JExpr.ref(fieldName); - - methodBody.assign(field, JExpr._new(holder.refClass(fieldType)).arg(holder.contextRef)); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ProduceProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ProduceProcessor.java deleted file mode 100644 index be05b9dbd0..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ProduceProcessor.java +++ /dev/null @@ -1,48 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.helper.CanonicalNameConstants.PRODUCE; - -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; - -import org.androidannotations.helper.APTCodeModelHelper; - -import com.sun.codemodel.JClassAlreadyExistsException; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JMethod; - -public class ProduceProcessor implements DecoratingElementProcessor { - - private final APTCodeModelHelper helper = new APTCodeModelHelper(); - - @Override - public String getTarget() { - return PRODUCE; - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) throws JClassAlreadyExistsException { - - ExecutableElement executableElement = (ExecutableElement) element; - - JMethod delegatingMethod = helper.overrideAnnotatedMethod(executableElement, holder); - - delegatingMethod.annotate(holder.refClass(PRODUCE)); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ResProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ResProcessor.java deleted file mode 100644 index 7fce7b2ad9..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ResProcessor.java +++ /dev/null @@ -1,88 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.invoke; -import static com.sun.codemodel.JExpr.ref; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.type.TypeMirror; - -import org.androidannotations.annotations.res.HtmlRes; -import org.androidannotations.helper.CanonicalNameConstants; -import org.androidannotations.helper.IdAnnotationHelper; -import org.androidannotations.model.AndroidRes; -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.JFieldRef; - -public class ResProcessor implements DecoratingElementProcessor { - - private final AndroidRes androidValue; - - private final IdAnnotationHelper annotationHelper; - - public ResProcessor(ProcessingEnvironment processingEnv, AndroidRes androidValue, IRClass rClass) { - this.androidValue = androidValue; - annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - } - - @Override - public String getTarget() { - return androidValue.getTarget(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - Classes classes = holder.classes(); - - String fieldName = element.getSimpleName().toString(); - - Res resInnerClass = androidValue.getRInnerClass(); - - JFieldRef idRef = annotationHelper.extractOneAnnotationFieldRef(holder, element, resInnerClass, true); - - JBlock methodBody = holder.initBody; - - TypeMirror fieldTypeMirror = element.asType(); - String fieldType = fieldTypeMirror.toString(); - - // Special case for loading animations - if (CanonicalNameConstants.ANIMATION.equals(fieldType)) { - methodBody.assign(ref(fieldName), classes.ANIMATION_UTILS.staticInvoke("loadAnimation").arg(holder.contextRef).arg(idRef)); - } else { - if (holder.resources == null) { - holder.resources = methodBody.decl(classes.RESOURCES, "resources_", holder.contextRef.invoke("getResources")); - } - - String resourceMethodName = androidValue.getResourceMethodName(); - - // Special case for @HtmlRes - if (element.getAnnotation(HtmlRes.class) != null) { - methodBody.assign(ref(fieldName), classes.HTML.staticInvoke("fromHtml").arg(invoke(holder.resources, resourceMethodName).arg(idRef))); - } else { - methodBody.assign(ref(fieldName), invoke(holder.resources, resourceMethodName).arg(idRef)); - } - } - - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/RestServiceProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/RestServiceProcessor.java deleted file mode 100644 index 52d42aa687..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/RestServiceProcessor.java +++ /dev/null @@ -1,53 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 javax.lang.model.element.Element; -import javax.lang.model.type.TypeMirror; - -import org.androidannotations.annotations.rest.RestService; -import org.androidannotations.helper.ModelConstants; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JFieldRef; - -public class RestServiceProcessor implements DecoratingElementProcessor { - - @Override - public String getTarget() { - return RestService.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - - String fieldName = element.getSimpleName().toString(); - - TypeMirror fieldTypeMirror = element.asType(); - String interfaceName = fieldTypeMirror.toString(); - - String generatedClassName = interfaceName + ModelConstants.GENERATION_SUFFIX; - - JBlock methodBody = holder.initBody; - - JFieldRef field = JExpr.ref(fieldName); - - methodBody.assign(field, JExpr._new(holder.refClass(generatedClassName))); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/RoboGuiceProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/RoboGuiceProcessor.java deleted file mode 100644 index 5980634ff7..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/RoboGuiceProcessor.java +++ /dev/null @@ -1,287 +0,0 @@ -/** - * Copyright (C) 2010-2013 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._super; -import static com.sun.codemodel.JExpr._this; -import static com.sun.codemodel.JExpr.cast; -import static com.sun.codemodel.JExpr.invoke; - -import java.util.ArrayList; -import java.util.List; -import java.util.Map; - -import javax.lang.model.element.AnnotationMirror; -import javax.lang.model.element.AnnotationValue; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; - -import org.androidannotations.annotations.RoboGuice; -import org.androidannotations.processing.EBeansHolder.Classes; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JExpression; -import com.sun.codemodel.JFieldVar; -import com.sun.codemodel.JInvocation; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JMod; -import com.sun.codemodel.JTryBlock; -import com.sun.codemodel.JVar; - -public class RoboGuiceProcessor implements DecoratingElementProcessor { - - @Override - public String getTarget() { - return RoboGuice.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - - holder.generatedClass._implements(holder.classes().INJECTOR_PROVIDER); - - // Fields - JFieldVar scope = scopeField(holder); - JFieldVar eventManager = eventManagerField(holder); - listenerFields(element, holder); - - // Methods - afterSetContentView(codeModel, holder, scope, eventManager); - onRestartMethod(codeModel, holder, scope, eventManager); - onStartMethod(codeModel, holder, scope, eventManager); - onResumeMethod(codeModel, holder, scope, eventManager); - onPauseMethod(codeModel, holder, scope, eventManager); - onNewIntentMethod(codeModel, holder, scope, eventManager); - onStopMethod(codeModel, holder, scope, eventManager); - onDestroyMethod(codeModel, holder, scope, eventManager); - onConfigurationChangedMethod(codeModel, holder, scope, eventManager); - onContentChangedMethod(codeModel, holder, scope, eventManager); - onActivityResultMethod(codeModel, holder, scope, eventManager); - - JMethod getInjectorMethod = getInjectorMethod(holder); - - beforeCreateMethod(holder, scope, eventManager, getInjectorMethod); - - } - - private JMethod getInjectorMethod(EBeanHolder holder) { - JMethod method = holder.generatedClass.method(JMod.PUBLIC, holder.classes().INJECTOR, "getInjector"); - method.annotate(Override.class); - JExpression castApplication = cast(holder.classes().INJECTOR_PROVIDER, invoke("getApplication")); - method.body()._return(castApplication.invoke("getInjector")); - return method; - } - - private void onRestartMethod(JCodeModel codeModel, EBeanHolder holder, JFieldVar scope, JFieldVar eventManager) { - JMethod method = holder.generatedClass.method(JMod.PUBLIC, codeModel.VOID, "onRestart"); - method.annotate(Override.class); - JBlock body = method.body(); - body.invoke(scope, "enter").arg(_this()); - body.invoke(_super(), method); - fireEvent(holder, eventManager, body, holder.classes().ON_RESTART_EVENT); - } - - private void onStartMethod(JCodeModel codeModel, EBeanHolder holder, JFieldVar scope, JFieldVar eventManager) { - JMethod method = holder.generatedClass.method(JMod.PUBLIC, codeModel.VOID, "onStart"); - method.annotate(Override.class); - JBlock body = method.body(); - body.invoke(scope, "enter").arg(_this()); - body.invoke(_super(), method); - fireEvent(holder, eventManager, body, holder.classes().ON_START_EVENT); - } - - private void onResumeMethod(JCodeModel codeModel, EBeanHolder holder, JFieldVar scope, JFieldVar eventManager) { - JMethod method = holder.generatedClass.method(JMod.PUBLIC, codeModel.VOID, "onResume"); - method.annotate(Override.class); - holder.onResumeBlock = method.body(); - holder.onResumeBlock.invoke(scope, "enter").arg(_this()); - holder.onResumeBlock.invoke(_super(), method); - fireEvent(holder, eventManager, holder.onResumeBlock, holder.classes().ON_RESUME_EVENT); - } - - private void onPauseMethod(JCodeModel codeModel, EBeanHolder holder, JFieldVar scope, JFieldVar eventManager) { - JMethod method = holder.generatedClass.method(JMod.PUBLIC, codeModel.VOID, "onPause"); - method.annotate(Override.class); - JBlock body = method.body(); - body.invoke(_super(), method); - fireEvent(holder, eventManager, body, holder.classes().ON_PAUSE_EVENT); - } - - private void onNewIntentMethod(JCodeModel codeModel, EBeanHolder holder, JFieldVar scope, JFieldVar eventManager) { - JMethod method = holder.generatedClass.method(JMod.PUBLIC, codeModel.VOID, "onNewIntent"); - method.annotate(Override.class); - JVar intent = method.param(holder.classes().INTENT, "intent"); - JBlock body = method.body(); - body.invoke(_super(), method).arg(intent); - body.invoke(scope, "enter").arg(_this()); - fireEvent(holder, eventManager, body, holder.classes().ON_NEW_INTENT_EVENT); - } - - private void fireEvent(EBeanHolder holder, JFieldVar eventManager, JBlock body, JClass eventClass, JExpression... eventArguments) { - JInvocation newEvent = _new(eventClass); - for (JExpression eventArgument : eventArguments) { - newEvent.arg(eventArgument); - } - body.invoke(eventManager, "fire").arg(newEvent); - } - - private void onStopMethod(JCodeModel codeModel, EBeanHolder holder, JFieldVar scope, JFieldVar eventManager) { - JMethod method = holder.generatedClass.method(JMod.PUBLIC, codeModel.VOID, "onStop"); - method.annotate(Override.class); - JBlock body = method.body(); - body.invoke(scope, "enter").arg(_this()); - - JTryBlock tryBlock = body._try(); - fireEvent(holder, eventManager, tryBlock.body(), holder.classes().ON_STOP_EVENT); - JBlock finallyBody = tryBlock._finally(); - - finallyBody.invoke(scope, "exit").arg(_this()); - finallyBody.invoke(_super(), method); - } - - private void onDestroyMethod(JCodeModel codeModel, EBeanHolder holder, JFieldVar scope, JFieldVar eventManager) { - JMethod method = holder.generatedClass.method(JMod.PUBLIC, codeModel.VOID, "onDestroy"); - method.annotate(Override.class); - holder.onDestroyBlock = method.body(); - holder.onDestroyBlock.invoke(scope, "enter").arg(_this()); - - JTryBlock tryBlock = holder.onDestroyBlock._try(); - fireEvent(holder, eventManager, tryBlock.body(), holder.classes().ON_DESTROY_EVENT); - JBlock finallyBody = tryBlock._finally(); - - finallyBody.invoke(eventManager, "clear").arg(_this()); - finallyBody.invoke(scope, "exit").arg(_this()); - finallyBody.invoke(scope, "dispose").arg(_this()); - finallyBody.invoke(_super(), method); - } - - private void onConfigurationChangedMethod(JCodeModel codeModel, EBeanHolder holder, JFieldVar scope, JFieldVar eventManager) { - JMethod method = holder.generatedClass.method(JMod.PUBLIC, codeModel.VOID, "onConfigurationChanged"); - method.annotate(Override.class); - JClass configurationClass = holder.classes().CONFIGURATION; - JVar newConfig = method.param(configurationClass, "newConfig"); - - JBlock body = method.body(); - JVar currentConfig = body.decl(configurationClass, "currentConfig", JExpr.invoke("getResources").invoke("getConfiguration")); - - body.invoke(_super(), method).arg(newConfig); - fireEvent(holder, eventManager, body, holder.classes().ON_CONFIGURATION_CHANGED_EVENT, currentConfig, newConfig); - } - - private void onContentChangedMethod(JCodeModel codeModel, EBeanHolder holder, JFieldVar scope, JFieldVar eventManager) { - JMethod method = holder.generatedClass.method(JMod.PUBLIC, codeModel.VOID, "onContentChanged"); - method.annotate(Override.class); - JBlock body = method.body(); - body.invoke(_super(), method); - fireEvent(holder, eventManager, body, holder.classes().ON_CONTENT_CHANGED_EVENT); - } - - private void onActivityResultMethod(JCodeModel codeModel, EBeanHolder holder, JFieldVar scope, JFieldVar eventManager) { - JMethod method = holder.generatedClass.method(JMod.PUBLIC, codeModel.VOID, "onActivityResult"); - method.annotate(Override.class); - JVar requestCode = method.param(codeModel.INT, "requestCode"); - JVar resultCode = method.param(codeModel.INT, "resultCode"); - JVar data = method.param(holder.classes().INTENT, "data"); - - JBlock body = method.body(); - - body.invoke(_super(), method).arg(requestCode).arg(resultCode).arg(data); - - body.invoke(scope, "enter").arg(_this()); - - JTryBlock tryBlock = body._try(); - fireEvent(holder, eventManager, tryBlock.body(), holder.classes().ON_ACTIVITY_RESULT_EVENT, requestCode, resultCode, data); - - JBlock finallyBody = tryBlock._finally(); - finallyBody.invoke(scope, "exit").arg(_this()); - } - - private void afterSetContentView(JCodeModel codeModel, EBeanHolder holder, JFieldVar scope, JFieldVar eventManager) { - JBlock onViewChanged = holder.onViewChanged().body(); - onViewChanged.invoke(scope, "injectViews"); - fireEvent(holder, eventManager, onViewChanged, holder.classes().ON_CONTENT_VIEW_AVAILABLE_EVENT); - } - - private JFieldVar eventManagerField(EBeanHolder holder) { - JFieldVar eventManager = holder.generatedClass.field(JMod.PRIVATE, holder.classes().EVENT_MANAGER, "eventManager_"); - return eventManager; - } - - private JFieldVar scopeField(EBeanHolder holder) { - JFieldVar scope = holder.generatedClass.field(JMod.PRIVATE, holder.classes().CONTEXT_SCOPE, "scope_"); - return scope; - } - - private void listenerFields(Element element, EBeanHolder holder) { - List listenerClasses = extractListenerClasses(element); - if (listenerClasses.size() > 0) { - int i = 1; - for (String listenerClassName : listenerClasses) { - JClass listenerClass = holder.refClass(listenerClassName); - JFieldVar listener = holder.generatedClass.field(JMod.PRIVATE, listenerClass, "listener" + i + "_"); - listener.annotate(SuppressWarnings.class).param("value", "unused"); - listener.annotate(holder.classes().INJECT); - i++; - } - } - } - - private List extractListenerClasses(Element activityElement) { - - List annotationMirrors = activityElement.getAnnotationMirrors(); - - String annotationName = RoboGuice.class.getName(); - AnnotationValue action = null; - for (AnnotationMirror annotationMirror : annotationMirrors) { - if (annotationName.equals(annotationMirror.getAnnotationType().toString())) { - for (Map.Entry entry : annotationMirror.getElementValues().entrySet()) { - if ("value".equals(entry.getKey().getSimpleName().toString())) { - action = entry.getValue(); - - @SuppressWarnings("unchecked") - List values = (List) action.getValue(); - - List listenerClasses = new ArrayList(); - - for (Object value : values) { - listenerClasses.add(value.toString()); - } - return listenerClasses; - - } - } - } - } - return new ArrayList(0); - } - - private void beforeCreateMethod(EBeanHolder holder, JFieldVar scope, JFieldVar eventManager, JMethod getInjector) { - Classes classes = holder.classes(); - - JBlock body = holder.initBody; - JVar injector = body.decl(classes.INJECTOR, "injector_", invoke(getInjector)); - body.assign(scope, invoke(injector, "getInstance").arg(classes.CONTEXT_SCOPE.dotclass())); - body.invoke(scope, "enter").arg(_this()); - body.invoke(injector, "injectMembers").arg(_this()); - body.assign(eventManager, invoke(injector, "getInstance").arg(classes.EVENT_MANAGER.dotclass())); - fireEvent(holder, eventManager, body, holder.classes().ON_CREATE_EVENT, holder.beforeCreateSavedInstanceStateParam); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/RootContextProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/RootContextProcessor.java deleted file mode 100644 index a8c0d455c9..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/RootContextProcessor.java +++ /dev/null @@ -1,58 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.cast; -import static com.sun.codemodel.JExpr.ref; -import static org.androidannotations.helper.CanonicalNameConstants.CONTEXT; - -import javax.lang.model.element.Element; -import javax.lang.model.type.TypeMirror; - -import org.androidannotations.annotations.RootContext; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; - -public class RootContextProcessor implements DecoratingElementProcessor { - - @Override - public String getTarget() { - return RootContext.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - - String fieldName = element.getSimpleName().toString(); - - TypeMirror elementType = element.asType(); - - String typeQualifiedName = elementType.toString(); - - JBlock body = holder.initBody; - if (CONTEXT.equals(typeQualifiedName)) { - body.assign(ref(fieldName), holder.contextRef); - } else { - JClass extendingContextClass = holder.refClass(typeQualifiedName); - body._if(holder.contextRef._instanceof(extendingContextClass)) // - ._then() // - .assign(ref(fieldName), cast(extendingContextClass, holder.contextRef)); - } - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/SeekBarProgressChangeProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/SeekBarProgressChangeProcessor.java deleted file mode 100644 index f2610f68ee..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/SeekBarProgressChangeProcessor.java +++ /dev/null @@ -1,116 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.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.SeekBarProgressChange; -import org.androidannotations.helper.APTCodeModelHelper; -import org.androidannotations.helper.CanonicalNameConstants; -import org.androidannotations.helper.OnSeekBarChangeListenerHelper; -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.JExpression; -import com.sun.codemodel.JFieldRef; -import com.sun.codemodel.JInvocation; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JVar; - -/** - */ -public class SeekBarProgressChangeProcessor implements DecoratingElementProcessor { - - private final OnSeekBarChangeListenerHelper helper; - - private final APTCodeModelHelper codeModelHelper; - - public SeekBarProgressChangeProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - codeModelHelper = new APTCodeModelHelper(); - helper = new OnSeekBarChangeListenerHelper(processingEnv, getTarget(), rClass, codeModelHelper); - } - - @Override - public String getTarget() { - return SeekBarProgressChange.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - - String methodName = element.getSimpleName().toString(); - - ExecutableElement executableElement = (ExecutableElement) element; - List parameters = executableElement.getParameters(); - - int seekBarViewParameterPosition = -1; - int progressParameterPosition = -1; - int fromUserParameterPosition = -1; - - for (int i = 0; i < parameters.size(); i++) { - VariableElement parameter = parameters.get(i); - TypeMirror parameterType = parameter.asType(); - - if (CanonicalNameConstants.SEEKBAR.equals(parameterType.toString())) { - seekBarViewParameterPosition = i; - } else if (parameterType.getKind() == TypeKind.INT || CanonicalNameConstants.INTEGER.equals(parameterType.toString())) { - progressParameterPosition = i; - } else if (parameterType.getKind() == TypeKind.BOOLEAN || CanonicalNameConstants.BOOLEAN.equals(parameterType.toString())) { - fromUserParameterPosition = i; - } - } - - List idsRefs = helper.extractAnnotationFieldRefs(holder, element, Res.ID, true); - - for (JFieldRef idRef : idsRefs) { - OnSeekBarChangeListenerHolder onSeekBarChangeListenerHolder = helper.getOrCreateListener(codeModel, holder, idRef); - - JInvocation textChangeCall; - JMethod methodToCall = onSeekBarChangeListenerHolder.onProgressChangedMethod; - - JBlock previousBody = codeModelHelper.removeBody(methodToCall); - JBlock methodBody = methodToCall.body(); - - methodBody.add(previousBody); - JExpression activityRef = holder.generatedClass.staticRef("this"); - textChangeCall = methodBody.invoke(activityRef, methodName); - - for (int i = 0; i < parameters.size(); i++) { - if (i == seekBarViewParameterPosition) { - JVar seekBarViewParameter = codeModelHelper.findParameterByName(methodToCall, "seekBar"); - textChangeCall.arg(seekBarViewParameter); - } else if (i == progressParameterPosition) { - JVar progressParameter = codeModelHelper.findParameterByName(methodToCall, "progress"); - textChangeCall.arg(progressParameter); - } else if (i == fromUserParameterPosition) { - JVar fromUserParameter = codeModelHelper.findParameterByName(methodToCall, "fromUser"); - textChangeCall.arg(fromUserParameter); - } - } - - } - - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/SeekBarTouchStartProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/SeekBarTouchStartProcessor.java deleted file mode 100644 index 2fd960de74..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/SeekBarTouchStartProcessor.java +++ /dev/null @@ -1,43 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 javax.annotation.processing.ProcessingEnvironment; - -import org.androidannotations.annotations.SeekBarTouchStart; -import org.androidannotations.rclass.IRClass; - -import com.sun.codemodel.JMethod; - -/** - */ -public class SeekBarTouchStartProcessor extends AbstractTrackingTouchProcessor { - - public SeekBarTouchStartProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - super(processingEnv, rClass); - } - - @Override - public String getTarget() { - return SeekBarTouchStart.class.getName(); - } - - @Override - protected JMethod getMethodToCall(OnSeekBarChangeListenerHolder onSeekBarChangeListenerHolder) { - JMethod methodToCall = onSeekBarChangeListenerHolder.onStartTrackingTouchMethod; - return methodToCall; - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/SeekBarTouchStopProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/SeekBarTouchStopProcessor.java deleted file mode 100644 index 712dd36523..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/SeekBarTouchStopProcessor.java +++ /dev/null @@ -1,44 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 javax.annotation.processing.ProcessingEnvironment; - -import org.androidannotations.annotations.SeekBarTouchStop; -import org.androidannotations.rclass.IRClass; - -import com.sun.codemodel.JMethod; - -/** - */ -public class SeekBarTouchStopProcessor extends AbstractTrackingTouchProcessor { - - public SeekBarTouchStopProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - super(processingEnv, rClass); - } - - @Override - public String getTarget() { - return SeekBarTouchStop.class.getName(); - } - - @Override - protected JMethod getMethodToCall(OnSeekBarChangeListenerHolder onSeekBarChangeListenerHolder) { - JMethod methodToCall = onSeekBarChangeListenerHolder.onStopTrackingTouchMethod; - return methodToCall; - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/SharedPrefProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/SharedPrefProcessor.java deleted file mode 100644 index 9ab16d3d37..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/SharedPrefProcessor.java +++ /dev/null @@ -1,338 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.invoke; -import static com.sun.codemodel.JExpr.lit; -import static com.sun.codemodel.JMod.PRIVATE; -import static com.sun.codemodel.JMod.STATIC; -import static org.androidannotations.helper.CanonicalNameConstants.CONTEXT; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.TypeElement; -import javax.lang.model.util.ElementFilter; - -import org.androidannotations.annotations.sharedpreferences.DefaultBoolean; -import org.androidannotations.annotations.sharedpreferences.DefaultFloat; -import org.androidannotations.annotations.sharedpreferences.DefaultInt; -import org.androidannotations.annotations.sharedpreferences.DefaultLong; -import org.androidannotations.annotations.sharedpreferences.DefaultRes; -import org.androidannotations.annotations.sharedpreferences.DefaultString; -import org.androidannotations.annotations.sharedpreferences.SharedPref; -import org.androidannotations.annotations.sharedpreferences.SharedPref.Scope; -import org.androidannotations.api.sharedpreferences.AbstractPrefEditorField; -import org.androidannotations.api.sharedpreferences.AbstractPrefField; -import org.androidannotations.api.sharedpreferences.BooleanPrefEditorField; -import org.androidannotations.api.sharedpreferences.BooleanPrefField; -import org.androidannotations.api.sharedpreferences.EditorHelper; -import org.androidannotations.api.sharedpreferences.FloatPrefEditorField; -import org.androidannotations.api.sharedpreferences.FloatPrefField; -import org.androidannotations.api.sharedpreferences.IntPrefEditorField; -import org.androidannotations.api.sharedpreferences.IntPrefField; -import org.androidannotations.api.sharedpreferences.LongPrefEditorField; -import org.androidannotations.api.sharedpreferences.LongPrefField; -import org.androidannotations.api.sharedpreferences.SharedPreferencesCompat; -import org.androidannotations.api.sharedpreferences.SharedPreferencesHelper; -import org.androidannotations.api.sharedpreferences.StringPrefEditorField; -import org.androidannotations.api.sharedpreferences.StringPrefField; -import org.androidannotations.helper.CanonicalNameConstants; -import org.androidannotations.helper.IdAnnotationHelper; -import org.androidannotations.helper.ModelConstants; -import org.androidannotations.rclass.IRClass; -import org.androidannotations.rclass.IRClass.Res; - -import com.sun.codemodel.ClassType; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JDefinedClass; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JExpression; -import com.sun.codemodel.JFieldRef; -import com.sun.codemodel.JFieldVar; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JMod; -import com.sun.codemodel.JVar; - -public class SharedPrefProcessor implements GeneratingElementProcessor { - - private static class EditorFieldHolder { - public final Class fieldClass; - public final String fieldMethodName; - - public EditorFieldHolder(Class fieldClass, String fieldMethodName) { - this.fieldClass = fieldClass; - this.fieldMethodName = fieldMethodName; - } - } - - private static final Map EDITOR_FIELD_BY_TYPE = new HashMap() { - private static final long serialVersionUID = 1L; - { - put("boolean", new EditorFieldHolder(BooleanPrefEditorField.class, "booleanField")); - put("float", new EditorFieldHolder(FloatPrefEditorField.class, "floatField")); - put("int", new EditorFieldHolder(IntPrefEditorField.class, "intField")); - put("long", new EditorFieldHolder(LongPrefEditorField.class, "longField")); - put(CanonicalNameConstants.STRING, new EditorFieldHolder(StringPrefEditorField.class, "stringField")); - } - }; - - private final IdAnnotationHelper annotationHelper; - - public SharedPrefProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - } - - @Override - public String getTarget() { - return SharedPref.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeansHolder eBeansHolder) throws Exception { - generateApiClass(element, eBeansHolder); - - TypeElement typeElement = (TypeElement) element; - String interfaceQualifiedName = typeElement.getQualifiedName().toString(); - String interfaceSimpleName = typeElement.getSimpleName().toString(); - - String helperQualifiedName = interfaceQualifiedName + ModelConstants.GENERATION_SUFFIX; - JDefinedClass helperClass = codeModel._class(JMod.PUBLIC | JMod.FINAL, helperQualifiedName, ClassType.CLASS); - EBeanHolder eBeanHolder = eBeansHolder.create(typeElement, SharedPref.class, helperClass); - - helperClass._extends(SharedPreferencesHelper.class); - - // Extracting valid methods - List members = typeElement.getEnclosedElements(); - List methods = ElementFilter.methodsIn(members); - List validMethods = new ArrayList(); - for (ExecutableElement method : methods) { - validMethods.add(method); - } - - // Static editor class - JDefinedClass editorClass = helperClass._class(JMod.PUBLIC | JMod.STATIC | JMod.FINAL, interfaceSimpleName + "Editor" + ModelConstants.GENERATION_SUFFIX); - - editorClass._extends(eBeansHolder.refClass(EditorHelper.class).narrow(editorClass)); - - // Editor constructor - JMethod editorConstructor = editorClass.constructor(JMod.NONE); - JClass sharedPreferencesClass = eBeansHolder.refClass("android.content.SharedPreferences"); - JVar sharedPreferencesParam = editorConstructor.param(sharedPreferencesClass, "sharedPreferences"); - editorConstructor.body().invoke("super").arg(sharedPreferencesParam); - - // Editor field methods - for (ExecutableElement method : validMethods) { - String returnType = method.getReturnType().toString(); - EditorFieldHolder editorFieldHolder = EDITOR_FIELD_BY_TYPE.get(returnType); - JClass editorFieldClass = eBeansHolder.refClass(editorFieldHolder.fieldClass); - String fieldName = method.getSimpleName().toString(); - JMethod editorFieldMethod = editorClass.method(JMod.PUBLIC, editorFieldClass.narrow(editorClass), fieldName); - editorFieldMethod.body()._return(JExpr.invoke(editorFieldHolder.fieldMethodName).arg(fieldName)); - } - - // Helper constructor - JClass contextClass = eBeansHolder.refClass(CanonicalNameConstants.CONTEXT); - - SharedPref sharedPrefAnnotation = typeElement.getAnnotation(SharedPref.class); - Scope scope = sharedPrefAnnotation.value(); - int mode = sharedPrefAnnotation.mode(); - JMethod constructor = helperClass.constructor(JMod.PUBLIC); - JVar contextParam = constructor.param(contextClass, "context"); - switch (scope) { - case ACTIVITY_DEFAULT: { - JMethod getLocalClassName = getLocalClassName(eBeansHolder, helperClass, codeModel); - constructor.body().invoke("super") // - .arg(contextParam.invoke("getSharedPreferences") // - .arg(invoke(getLocalClassName).arg(contextParam)) // - .arg(JExpr.lit(mode))); - break; - } - case ACTIVITY: { - JMethod getLocalClassName = getLocalClassName(eBeansHolder, helperClass, codeModel); - constructor.body().invoke("super") // - .arg(contextParam.invoke("getSharedPreferences") // - .arg(invoke(getLocalClassName).arg(contextParam) // - .plus(JExpr.lit("_" + interfaceSimpleName))) // - .arg(JExpr.lit(mode))); - break; - } - case UNIQUE: { - constructor.body() // - .invoke("super") // - .arg(contextParam.invoke("getSharedPreferences") // - .arg(JExpr.lit(interfaceSimpleName)) // - .arg(JExpr.lit(mode))); - break; - } - case APPLICATION_DEFAULT: { - JClass preferenceManagerClass = eBeansHolder.refClass("android.preference.PreferenceManager"); - constructor.body() // - .invoke("super") // - .arg(preferenceManagerClass.staticInvoke("getDefaultSharedPreferences") // - .arg(contextParam)); - break; - } - } - - // Context field - JFieldVar contextField = helperClass.field(JMod.PRIVATE, eBeansHolder.refClass(CONTEXT), "context"); - constructor.body().assign(JExpr._this().ref(contextField), contextParam); - - // Helper edit method - JMethod editMethod = helperClass.method(JMod.PUBLIC, editorClass, "edit"); - editMethod.body()._return(JExpr._new(editorClass).arg(JExpr.invoke("getSharedPreferences"))); - - // Helper field methods - for (ExecutableElement method : validMethods) { - String returnType = method.getReturnType().toString(); - String fieldName = method.getSimpleName().toString(); - if ("boolean".equals(returnType)) { - JExpression defaultValue; - DefaultBoolean defaultAnnotation = method.getAnnotation(DefaultBoolean.class); - if (defaultAnnotation != null) { - defaultValue = JExpr.lit(defaultAnnotation.value()); - } else if (method.getAnnotation(DefaultRes.class) != null) { - defaultValue = extractResValue(eBeanHolder, method, contextField, Res.BOOL); - } else { - defaultValue = JExpr.lit(false); - } - addFieldHelperMethod(helperClass, fieldName, defaultValue, BooleanPrefField.class, "booleanField"); - } else if ("float".equals(returnType)) { - JExpression defaultValue; - DefaultFloat defaultAnnotation = method.getAnnotation(DefaultFloat.class); - if (defaultAnnotation != null) { - defaultValue = JExpr.lit(defaultAnnotation.value()); - } else if (method.getAnnotation(DefaultRes.class) != null) { - defaultValue = extractResValue(eBeanHolder, method, contextField, Res.INTEGER); - } else { - defaultValue = JExpr.lit(0f); - } - addFieldHelperMethod(helperClass, fieldName, defaultValue, FloatPrefField.class, "floatField"); - } else if ("int".equals(returnType)) { - JExpression defaultValue; - DefaultInt defaultAnnotation = method.getAnnotation(DefaultInt.class); - if (defaultAnnotation != null) { - defaultValue = JExpr.lit(defaultAnnotation.value()); - } else if (method.getAnnotation(DefaultRes.class) != null) { - defaultValue = extractResValue(eBeanHolder, method, contextField, Res.INTEGER); - } else { - defaultValue = JExpr.lit(0); - } - addFieldHelperMethod(helperClass, fieldName, defaultValue, IntPrefField.class, "intField"); - } else if ("long".equals(returnType)) { - JExpression defaultValue; - DefaultLong defaultAnnotation = method.getAnnotation(DefaultLong.class); - if (defaultAnnotation != null) { - defaultValue = JExpr.lit(defaultAnnotation.value()); - } else if (method.getAnnotation(DefaultRes.class) != null) { - defaultValue = extractResValue(eBeanHolder, method, contextField, Res.INTEGER); - } else { - defaultValue = JExpr.lit(0l); - } - addFieldHelperMethod(helperClass, fieldName, defaultValue, LongPrefField.class, "longField"); - } else if (CanonicalNameConstants.STRING.equals(returnType)) { - JExpression defaultValue; - DefaultString defaultAnnotation = method.getAnnotation(DefaultString.class); - if (defaultAnnotation != null) { - defaultValue = JExpr.lit(defaultAnnotation.value()); - } else if (method.getAnnotation(DefaultRes.class) != null) { - defaultValue = extractResValue(eBeanHolder, method, contextField, Res.STRING); - } else { - defaultValue = JExpr.lit(""); - } - addFieldHelperMethod(helperClass, fieldName, defaultValue, StringPrefField.class, "stringField"); - } - } - } - - private JExpression extractResValue(EBeanHolder eBeanHolder, Element method, JFieldVar contextField, Res res) { - JFieldRef idRef = annotationHelper.extractOneAnnotationFieldRef(eBeanHolder, method, DefaultRes.class.getCanonicalName(), res, true); - - String resourceGetMethodName = null; - switch (res) { - case BOOL: - resourceGetMethodName = "getBoolean"; - break; - case INTEGER: - resourceGetMethodName = "getInteger"; - break; - case STRING: - resourceGetMethodName = "getString"; - break; - default: - break; - } - return contextField.invoke("getResources").invoke(resourceGetMethodName).arg(idRef); - } - - private void addFieldHelperMethod(JDefinedClass helperClass, String fieldName, JExpression defaultValue, Class prefFieldHelperClass, String fieldHelperMethodName) { - JMethod fieldMethod = helperClass.method(JMod.PUBLIC, prefFieldHelperClass, fieldName); - fieldMethod.body()._return(JExpr.invoke(fieldHelperMethodName).arg(fieldName).arg(defaultValue)); - } - - private JMethod getLocalClassName(EBeansHolder eBeansHolder, JDefinedClass helperClass, JCodeModel codeModel) { - - JClass stringClass = eBeansHolder.refClass(String.class); - JMethod getLocalClassName = helperClass.method(PRIVATE | STATIC, stringClass, "getLocalClassName"); - JClass contextClass = eBeansHolder.refClass(CanonicalNameConstants.CONTEXT); - - JVar contextParam = getLocalClassName.param(contextClass, "context"); - - JBlock body = getLocalClassName.body(); - - JVar packageName = body.decl(stringClass, "packageName", contextParam.invoke("getPackageName")); - - JVar className = body.decl(stringClass, "className", contextParam.invoke("getClass").invoke("getName")); - - JVar packageLen = body.decl(codeModel.INT, "packageLen", packageName.invoke("length")); - - JExpression condition = className.invoke("startsWith").arg(packageName).not() // - .cor(className.invoke("length").lte(packageLen)) // - .cor(className.invoke("charAt").arg(packageLen).ne(lit('.'))); - - body._if(condition)._then()._return(className); - - body._return(className.invoke("substring").arg(packageLen.plus(lit(1)))); - - return getLocalClassName; - } - - private void generateApiClass(Element originatingElement, EBeansHolder eBeansHolder) { - eBeansHolder.generateApiClass(originatingElement, AbstractPrefEditorField.class); - eBeansHolder.generateApiClass(originatingElement, AbstractPrefField.class); - eBeansHolder.generateApiClass(originatingElement, BooleanPrefEditorField.class); - eBeansHolder.generateApiClass(originatingElement, BooleanPrefField.class); - eBeansHolder.generateApiClass(originatingElement, EditorHelper.class); - eBeansHolder.generateApiClass(originatingElement, FloatPrefEditorField.class); - eBeansHolder.generateApiClass(originatingElement, FloatPrefField.class); - eBeansHolder.generateApiClass(originatingElement, IntPrefEditorField.class); - eBeansHolder.generateApiClass(originatingElement, IntPrefField.class); - eBeansHolder.generateApiClass(originatingElement, LongPrefEditorField.class); - eBeansHolder.generateApiClass(originatingElement, LongPrefField.class); - eBeansHolder.generateApiClass(originatingElement, SharedPreferencesCompat.class); - eBeansHolder.generateApiClass(originatingElement, SharedPreferencesHelper.class); - eBeansHolder.generateApiClass(originatingElement, StringPrefEditorField.class); - eBeansHolder.generateApiClass(originatingElement, StringPrefField.class); - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/SubscribeProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/SubscribeProcessor.java deleted file mode 100644 index e4b97e5cdf..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/SubscribeProcessor.java +++ /dev/null @@ -1,48 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.helper.CanonicalNameConstants.SUBSCRIBE; - -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; - -import org.androidannotations.helper.APTCodeModelHelper; - -import com.sun.codemodel.JClassAlreadyExistsException; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JMethod; - -public class SubscribeProcessor implements DecoratingElementProcessor { - - private final APTCodeModelHelper helper = new APTCodeModelHelper(); - - @Override - public String getTarget() { - return SUBSCRIBE; - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) throws JClassAlreadyExistsException { - - ExecutableElement executableElement = (ExecutableElement) element; - - JMethod delegatingMethod = helper.overrideAnnotatedMethod(executableElement, holder); - - delegatingMethod.annotate(holder.refClass(SUBSCRIBE)); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/SystemServiceProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/SystemServiceProcessor.java deleted file mode 100644 index e211b9b10f..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/SystemServiceProcessor.java +++ /dev/null @@ -1,59 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.cast; -import static com.sun.codemodel.JExpr.ref; - -import javax.lang.model.element.Element; -import javax.lang.model.type.TypeMirror; - -import org.androidannotations.annotations.SystemService; -import org.androidannotations.model.AndroidSystemServices; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JFieldRef; - -public class SystemServiceProcessor implements DecoratingElementProcessor { - - private final AndroidSystemServices androidSystemServices; - - public SystemServiceProcessor(AndroidSystemServices androidSystemServices) { - this.androidSystemServices = androidSystemServices; - } - - @Override - public String getTarget() { - return SystemService.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - - String fieldName = element.getSimpleName().toString(); - - TypeMirror serviceType = element.asType(); - String fieldTypeQualifiedName = serviceType.toString(); - - JFieldRef serviceRef = androidSystemServices.getServiceConstant(serviceType, holder); - - JBlock methodBody = holder.initBody; - - methodBody.assign(ref(fieldName), cast(holder.refClass(fieldTypeQualifiedName), holder.contextRef.invoke("getSystemService").arg(serviceRef))); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TextChangeProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TextChangeProcessor.java deleted file mode 100644 index bbed4b1d40..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TextChangeProcessor.java +++ /dev/null @@ -1,137 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.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.TextChange; -import org.androidannotations.helper.APTCodeModelHelper; -import org.androidannotations.helper.CanonicalNameConstants; -import org.androidannotations.helper.TextWatcherHelper; -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.JExpression; -import com.sun.codemodel.JFieldRef; -import com.sun.codemodel.JInvocation; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JVar; - -/** - */ -public class TextChangeProcessor implements DecoratingElementProcessor { - - private final TextWatcherHelper helper; - - private final APTCodeModelHelper codeModelHelper; - - public TextChangeProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - codeModelHelper = new APTCodeModelHelper(); - helper = new TextWatcherHelper(processingEnv, getTarget(), rClass, codeModelHelper); - } - - @Override - public String getTarget() { - return TextChange.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - - String methodName = element.getSimpleName().toString(); - - ExecutableElement executableElement = (ExecutableElement) element; - List parameters = executableElement.getParameters(); - - int startParameterPosition = -1; - int countParameterPosition = -1; - int beforeParameterPosition = -1; - int charSequenceParameterPosition = -1; - int viewParameterPosition = -1; - TypeMirror viewParameterType = null; - - for (int i = 0; i < parameters.size(); i++) { - VariableElement parameter = parameters.get(i); - String parameterName = parameter.toString(); - TypeMirror parameterType = parameter.asType(); - - if (CanonicalNameConstants.CHAR_SEQUENCE.equals(parameterType.toString())) { - charSequenceParameterPosition = i; - } else if (parameterType.getKind() == TypeKind.INT || CanonicalNameConstants.INTEGER.equals(parameterType.toString())) { - if ("start".equals(parameterName)) { - startParameterPosition = i; - } else if ("count".equals(parameterName)) { - countParameterPosition = i; - } else if ("before".equals(parameterName)) { - beforeParameterPosition = i; - } - } else { - TypeMirror textViewType = helper.typeElementFromQualifiedName(CanonicalNameConstants.TEXT_VIEW).asType(); - if (helper.isSubtype(parameterType, textViewType)) { - viewParameterPosition = i; - viewParameterType = parameterType; - } - } - } - - List idsRefs = helper.extractAnnotationFieldRefs(holder, element, Res.ID, true); - - for (JFieldRef idRef : idsRefs) { - TextWatcherHolder textWatcherHolder = helper.getOrCreateListener(codeModel, holder, idRef, viewParameterType); - - JInvocation textChangeCall; - JMethod methodToCall = textWatcherHolder.onTextChangedMethod; - - JBlock previousBody = codeModelHelper.removeBody(methodToCall); - JBlock methodBody = methodToCall.body(); - - methodBody.add(previousBody); - JExpression activityRef = holder.generatedClass.staticRef("this"); - textChangeCall = methodBody.invoke(activityRef, methodName); - - for (int i = 0; i < parameters.size(); i++) { - if (i == startParameterPosition) { - JVar startParameter = codeModelHelper.findParameterByName(methodToCall, "start"); - textChangeCall.arg(startParameter); - } else if (i == countParameterPosition) { - JVar countParameter = codeModelHelper.findParameterByName(methodToCall, "count"); - textChangeCall.arg(countParameter); - } else if (i == beforeParameterPosition) { - JVar beforeParameter = codeModelHelper.findParameterByName(methodToCall, "before"); - textChangeCall.arg(beforeParameter); - } else if (i == charSequenceParameterPosition) { - JVar charSequenceParam = codeModelHelper.findParameterByName(methodToCall, "s"); - textChangeCall.arg(charSequenceParam); - } else if (i == viewParameterPosition) { - JVar viewParameter = textWatcherHolder.viewVariable; - textChangeCall.arg(viewParameter); - } - } - - } - - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TextWatcherHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TextWatcherHolder.java deleted file mode 100644 index 87f85cbcc1..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TextWatcherHolder.java +++ /dev/null @@ -1,43 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 com.sun.codemodel.JMethod; -import com.sun.codemodel.JVar; - -public class TextWatcherHolder { - - final JMethod afterTextChangedMethod; - - final JMethod beforeTextChangedMethod; - - final JMethod onTextChangedMethod; - - final JVar viewVariable; - - public TextWatcherHolder(// - JMethod afterTextChangedMethod, // - JMethod beforeTextChangedMethod, // - JMethod onTextChangedMethod, JVar viewVariable) { - - this.afterTextChangedMethod = afterTextChangedMethod; - this.beforeTextChangedMethod = beforeTextChangedMethod; - this.onTextChangedMethod = onTextChangedMethod; - this.viewVariable = viewVariable; - - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TouchProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TouchProcessor.java deleted file mode 100644 index 338944342d..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TouchProcessor.java +++ /dev/null @@ -1,89 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.TypeKind; -import javax.lang.model.type.TypeMirror; - -import org.androidannotations.annotations.Touch; -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.JInvocation; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JMod; -import com.sun.codemodel.JVar; - -/** - */ -public class TouchProcessor extends AbstractListenerProcessor { - - public TouchProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - super(processingEnv, rClass); - } - - @Override - public String getTarget() { - return Touch.class.getName(); - } - - @Override - protected void makeCall(JBlock listenerMethodBody, JInvocation call, TypeMirror returnType) { - boolean returnMethodResult = returnType.getKind() != TypeKind.VOID; - - if (returnMethodResult) { - listenerMethodBody._return(call); - } else { - listenerMethodBody.add(call); - listenerMethodBody._return(JExpr.TRUE); - } - } - - @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); - } - } - - @Override - protected JMethod createListenerMethod(JDefinedClass listenerAnonymousClass) { - return listenerAnonymousClass.method(JMod.PUBLIC, codeModel.BOOLEAN, "onTouch"); - } - - @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/processing/TraceProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TraceProcessor.java deleted file mode 100644 index c00f02ace5..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TraceProcessor.java +++ /dev/null @@ -1,152 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.helper.AndroidConstants.LOG_DEBUG; -import static org.androidannotations.helper.AndroidConstants.LOG_ERROR; -import static org.androidannotations.helper.AndroidConstants.LOG_INFO; -import static org.androidannotations.helper.AndroidConstants.LOG_VERBOSE; -import static org.androidannotations.helper.AndroidConstants.LOG_WARN; - -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; - -import org.androidannotations.annotations.Trace; -import org.androidannotations.helper.APTCodeModelHelper; -import org.androidannotations.processing.EBeansHolder.Classes; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JConditional; -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.JTryBlock; -import com.sun.codemodel.JVar; - -public class TraceProcessor implements DecoratingElementProcessor { - - private final APTCodeModelHelper helper = new APTCodeModelHelper(); - - @Override - public String getTarget() { - return Trace.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - Classes classes = holder.classes(); - ExecutableElement executableElement = (ExecutableElement) element; - - String tag = extractTag(executableElement); - int level = executableElement.getAnnotation(Trace.class).level(); - - JMethod method = helper.overrideAnnotatedMethod(executableElement, holder); - - JBlock previousMethodBody = helper.removeBody(method); - - JBlock methodBody = method.body(); - - JInvocation isLoggableInvocation = classes.LOG.staticInvoke("isLoggable"); - isLoggableInvocation.arg(JExpr.lit(tag)).arg(logLevelFromInt(level, classes.LOG)); - - JConditional ifStatement = methodBody._if(isLoggableInvocation); - - JInvocation currentTimeInvoke = classes.SYSTEM.staticInvoke("currentTimeMillis"); - JBlock _thenBody = ifStatement._then(); - JVar startDeclaration = _thenBody.decl(codeModel.LONG, "start", currentTimeInvoke); - - String methodName = "[" + element.toString() + "]"; - - // Log In - String logMethodName = logMethodNameFromLevel(level); - JInvocation logEnterInvoke = classes.LOG.staticInvoke(logMethodName); - logEnterInvoke.arg(tag); - - JExpression enterMessage = JExpr.lit("Entering " + methodName); - logEnterInvoke.arg(enterMessage); - _thenBody.add(logEnterInvoke); - - JTryBlock tryBlock = _thenBody._try(); - - tryBlock.body().add(previousMethodBody); - - JBlock finallyBlock = tryBlock._finally(); - - JVar durationDeclaration = finallyBlock.decl(codeModel.LONG, "duration", currentTimeInvoke.minus(startDeclaration)); - - JInvocation logExitInvoke = classes.LOG.staticInvoke(logMethodName); - logExitInvoke.arg(tag); - - JExpression exitMessage = JExpr.lit("Exiting " + methodName + ", duration in ms: ").plus(durationDeclaration); - logExitInvoke.arg(exitMessage); - finallyBlock.add(logExitInvoke); - - JBlock elseBlock = ifStatement._else(); - - elseBlock.add(previousMethodBody); - } - - private String logMethodNameFromLevel(int level) { - switch (level) { - case LOG_DEBUG: - return "d"; - case LOG_VERBOSE: - return "v"; - case LOG_INFO: - return "i"; - case LOG_WARN: - return "w"; - case LOG_ERROR: - return "e"; - default: - throw new IllegalArgumentException("Unrecognized Log level : " + level); - } - } - - private JFieldRef logLevelFromInt(int level, JClass logClass) { - switch (level) { - case LOG_DEBUG: - return logClass.staticRef("DEBUG"); - case LOG_VERBOSE: - return logClass.staticRef("VERBOSE"); - case LOG_INFO: - return logClass.staticRef("INFO"); - case LOG_WARN: - return logClass.staticRef("WARN"); - case LOG_ERROR: - return logClass.staticRef("ERROR"); - default: - throw new IllegalArgumentException("Unrecognized log level. Given value:" + level); - } - } - - private String extractTag(Element element) { - Trace annotation = element.getAnnotation(Trace.class); - String tag = annotation.tag(); - if (Trace.DEFAULT_TAG.equals(tag)) { - tag = element.getEnclosingElement().getSimpleName().toString(); - } - if (tag.length() > 23) { - tag = tag.substring(0, 23); - } - return tag; - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TransactionalProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TransactionalProcessor.java deleted file mode 100644 index ba82a99f90..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/TransactionalProcessor.java +++ /dev/null @@ -1,98 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; - -import org.androidannotations.annotations.Transactional; -import org.androidannotations.helper.APTCodeModelHelper; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JCatchBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JExpression; -import com.sun.codemodel.JInvocation; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JTryBlock; -import com.sun.codemodel.JVar; - -public class TransactionalProcessor implements DecoratingElementProcessor { - - private final APTCodeModelHelper helper = new APTCodeModelHelper(); - - @Override - public String getTarget() { - return Transactional.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - - ExecutableElement executableElement = (ExecutableElement) element; - - String returnTypeName = executableElement.getReturnType().toString(); - JClass returnType = holder.refClass(returnTypeName); - - JMethod method = helper.overrideAnnotatedMethod(executableElement, holder); - helper.removeBody(method); - - JVar db = method.params().get(0); - - JBlock body = method.body(); - - body.invoke(db, "beginTransaction"); - - JTryBlock tryBlock = body._try(); - - JExpression activitySuper = holder.generatedClass.staticRef("super"); - JInvocation superCall = JExpr.invoke(activitySuper, method); - - for (JVar param : method.params()) { - superCall.arg(param); - } - JBlock tryBody = tryBlock.body(); - if (returnTypeName.equals("void")) { - tryBody.add(superCall); - tryBody.invoke(db, "setTransactionSuccessful"); - tryBody._return(); - } else { - JVar result = tryBody.decl(returnType, "result_", superCall); - tryBody.invoke(db, "setTransactionSuccessful"); - tryBody._return(result); - } - - JCatchBlock catchBlock = tryBlock._catch(holder.refClass(RuntimeException.class)); - - JVar exceptionParam = catchBlock.param("e"); - - JBlock catchBody = catchBlock.body(); - - JInvocation errorInvoke = catchBody.staticInvoke(holder.classes().LOG, "e"); - - errorInvoke.arg(holder.generatedClass.name()); - errorInvoke.arg("Error in transaction"); - errorInvoke.arg(exceptionParam); - - catchBody._throw(exceptionParam); - - tryBlock._finally().invoke(db, "endTransaction"); - - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/UiThreadProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/UiThreadProcessor.java deleted file mode 100644 index 16e1c00c59..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/UiThreadProcessor.java +++ /dev/null @@ -1,73 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.lit; - -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; - -import org.androidannotations.annotations.UiThread; -import org.androidannotations.helper.APTCodeModelHelper; - -import com.sun.codemodel.JClass; -import com.sun.codemodel.JClassAlreadyExistsException; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JDefinedClass; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JMod; - -public class UiThreadProcessor implements DecoratingElementProcessor { - - private final APTCodeModelHelper helper = new APTCodeModelHelper(); - - @Override - public String getTarget() { - return UiThread.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) throws JClassAlreadyExistsException { - - ExecutableElement executableElement = (ExecutableElement) element; - - JMethod delegatingMethod = helper.overrideAnnotatedMethod(executableElement, holder); - - JDefinedClass anonymousRunnableClass = helper.createDelegatingAnonymousRunnableClass(holder, delegatingMethod); - - { - // Execute Runnable - - UiThread annotation = element.getAnnotation(UiThread.class); - long delay = annotation.delay(); - - if (holder.handler == null) { - JClass handlerClass = holder.classes().HANDLER; - holder.handler = holder.generatedClass.field(JMod.PRIVATE, handlerClass, "handler_", JExpr._new(handlerClass)); - } - - if (delay == 0) { - delegatingMethod.body().invoke(holder.handler, "post").arg(_new(anonymousRunnableClass)); - } else { - delegatingMethod.body().invoke(holder.handler, "postDelayed").arg(_new(anonymousRunnableClass)).arg(lit(delay)); - } - } - - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ViewByIdProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ViewByIdProcessor.java deleted file mode 100644 index 9ad31c6f1f..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ViewByIdProcessor.java +++ /dev/null @@ -1,61 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.cast; -import static com.sun.codemodel.JExpr.ref; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.type.TypeMirror; - -import org.androidannotations.annotations.ViewById; -import org.androidannotations.helper.IdAnnotationHelper; -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.JFieldRef; - -public class ViewByIdProcessor implements DecoratingElementProcessor { - - private final IdAnnotationHelper annotationHelper; - - public ViewByIdProcessor(ProcessingEnvironment processingEnv, IRClass rClass) { - annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - } - - @Override - public String getTarget() { - return ViewById.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - String fieldName = element.getSimpleName().toString(); - - TypeMirror uiFieldTypeMirror = element.asType(); - String typeQualifiedName = uiFieldTypeMirror.toString(); - - JFieldRef idRef = annotationHelper.extractOneAnnotationFieldRef(holder, element, Res.ID, true); - - ViewChangedHolder onViewChanged = holder.onViewChanged(); - JBlock methodBody = onViewChanged.body(); - methodBody.assign(ref(fieldName), cast(holder.refClass(typeQualifiedName), onViewChanged.findViewById(idRef))); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ViewChangedHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ViewChangedHolder.java deleted file mode 100644 index a1f02530b4..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ViewChangedHolder.java +++ /dev/null @@ -1,47 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.invoke; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JFieldRef; -import com.sun.codemodel.JInvocation; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JVar; - -public class ViewChangedHolder { - - private JMethod onViewChanged; - private JVar onViewChangedHasViewsParam; - - public ViewChangedHolder(JMethod onViewChanged, JVar onViewChangedHasViewsParam) { - this.onViewChanged = onViewChanged; - this.onViewChangedHasViewsParam = onViewChangedHasViewsParam; - } - - public JBlock body() { - return onViewChanged.body(); - } - - public JInvocation findViewById(JFieldRef idRef) { - JInvocation findViewById = invoke(onViewChangedHasViewsParam, "findViewById"); - findViewById.arg(idRef); - return findViewById; - - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/WindowFeatureProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/WindowFeatureProcessor.java deleted file mode 100644 index b1107b356b..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/WindowFeatureProcessor.java +++ /dev/null @@ -1,42 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 javax.lang.model.element.Element; - -import org.androidannotations.annotations.WindowFeature; - -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JExpr; - -public class WindowFeatureProcessor implements DecoratingElementProcessor { - - @Override - public String getTarget() { - return WindowFeature.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - WindowFeature annotation = element.getAnnotation(WindowFeature.class); - int[] features = annotation.value(); - - for (int feature : features) { - holder.initBody.invoke("requestWindowFeature").arg(JExpr.lit(feature)); - } - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/DeleteProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/DeleteProcessor.java deleted file mode 100644 index 314e5937aa..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/DeleteProcessor.java +++ /dev/null @@ -1,49 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.rest; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; - -import org.androidannotations.annotations.rest.Delete; -import org.androidannotations.processing.EBeanHolder; - -import com.sun.codemodel.JCodeModel; - -public class DeleteProcessor extends MethodProcessor { - - public DeleteProcessor(ProcessingEnvironment processingEnv, RestImplementationsHolder restImplementationsHolder) { - super(processingEnv, restImplementationsHolder); - } - - @Override - public String getTarget() { - return Delete.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) throws Exception { - - ExecutableElement executableElement = (ExecutableElement) element; - - Delete deleteAnnotation = element.getAnnotation(Delete.class); - String urlSuffix = deleteAnnotation.value(); - - generateRestTemplateCallBlock(new MethodProcessorHolder(holder, executableElement, urlSuffix, null, null, codeModel)); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/GetPostProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/GetPostProcessor.java deleted file mode 100644 index 1afac17926..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/GetPostProcessor.java +++ /dev/null @@ -1,283 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.rest; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.TreeSet; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ElementKind; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.TypeElement; -import javax.lang.model.type.ArrayType; -import javax.lang.model.type.DeclaredType; -import javax.lang.model.type.TypeKind; -import javax.lang.model.type.TypeMirror; -import javax.lang.model.type.WildcardType; - -import org.androidannotations.helper.APTCodeModelHelper; -import org.androidannotations.helper.CanonicalNameConstants; -import org.androidannotations.processing.EBeanHolder; - -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JDefinedClass; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JInvocation; -import com.sun.codemodel.JPackage; - -public abstract class GetPostProcessor extends MethodProcessor { - - protected EBeanHolder holder; - - /** - * Will be use to generate specific classes - */ - protected JPackage restClientPackage; - - protected APTCodeModelHelper helper; - - public GetPostProcessor(ProcessingEnvironment processingEnv, RestImplementationsHolder restImplementationsHolder) { - super(processingEnv, restImplementationsHolder); - helper = new APTCodeModelHelper(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { - this.holder = holder; - restClientPackage = restImplementationsHolder.getEnclosingHolder(element).restImplementationClass._package(); - - String urlSuffix = retrieveUrlSuffix(element); - - ExecutableElement executableElement = (ExecutableElement) element; - MethodProcessorHolder processorHolder = new MethodProcessorHolder(holder, executableElement, urlSuffix, null, null, codeModel); - - // Retrieve return type - TypeMirror returnType = executableElement.getReturnType(); - if (returnType.getKind() != TypeKind.VOID) { - retrieveReturnAndExpectedClasses(returnType, processorHolder); - } - - generateRestTemplateCallBlock(processorHolder); - } - - public abstract String retrieveUrlSuffix(Element element); - - /** - * Retrieve the expected and method return classes to use in generated code. - *

- * If the annotated method return a ResponseEntity<T> then : - * - * 

-	 * expectedClass = T.class, methodReturnClass = ResponseEntity<T>
-	 *
- * - * - * @param returnType - * @param processorHolder - */ - public void retrieveReturnAndExpectedClasses(TypeMirror returnType, MethodProcessorHolder processorHolder) { - String returnTypeString = returnType.toString(); - - JClass expectedClass = null; - JClass returnClass = helper.typeMirrorToJClass(returnType, holder); - - if (returnTypeString.startsWith(CanonicalNameConstants.RESPONSE_ENTITY)) { - DeclaredType declaredReturnType = (DeclaredType) returnType; - if (declaredReturnType.getTypeArguments().size() > 0) { - expectedClass = resolveExpectedClass(declaredReturnType.getTypeArguments().get(0)); - } else { - expectedClass = holder.refClass(CanonicalNameConstants.RESPONSE_ENTITY); - } - } else { - expectedClass = resolveExpectedClass(returnType); - } - - processorHolder.setExpectedClass(expectedClass); - processorHolder.setMethodReturnClass(returnClass); - } - - /** - * Resolve the expected class for the input type according to the following - * rules : - *
    - *
  • The type is a primitive : Directly return the JClass as usual
    • - *
  • The type is NOT a generics : Directly return the JClass as usual
    • - *
  • The type is a generics and enclosing type is a class C<T> : - * Generate a subclass of C<T> and return it
    • - *
  • The type is a generics and enclosing type is an interface I<T> - * : Looking the inheritance tree, then
    • - *
      - *
    1. One of the parent is a {@link Map} : Generate a subclass of - * {@link LinkedHashMap}<T> one and return it
      2. - *
    2. One of the parent is a {@link Set} : Generate a subclass of - * {@link TreeSet}<T> one and return it
      3. - *
    3. One of the parent is a {@link Collection} : Generate a subclass of - * {@link ArrayList}<T> one and return it
      4. - *
    4. Return {@link Object} definition
      5. - *
    - *
- * - * @param expectedType - */ - private JClass resolveExpectedClass(TypeMirror expectedType) { - // is a class or an interface - if (expectedType.getKind() == TypeKind.DECLARED) { - DeclaredType declaredType = (DeclaredType) expectedType; - - List typeArguments = declaredType.getTypeArguments(); - - // is NOT a generics, return directly - if (typeArguments.isEmpty()) { - return helper.typeMirrorToJClass(declaredType, holder); - } - - // is a generics, must generate a new super class - TypeElement declaredElement = (TypeElement) declaredType.asElement(); - - JClass baseClass = helper.typeMirrorToJClass(declaredType, holder).erasure(); - JClass decoratedExpectedClass = retrieveDecoratedExpectedClass(declaredType, declaredElement); - if (decoratedExpectedClass == null) { - decoratedExpectedClass = baseClass; - } - return decoratedExpectedClass; - } else if (expectedType.getKind() == TypeKind.ARRAY) { - ArrayType arrayType = (ArrayType) expectedType; - return resolveExpectedClass(arrayType.getComponentType()).array(); - } - - // is not a class nor an interface, return directly - return helper.typeMirrorToJClass(expectedType, holder); - } - - /** - * Recursive method used to find if one of the grand-parent of the - * enclosingJClass is {@link Map}, {@link Set} or - * {@link Collection}. - * - * @param declaredType - * @param currentClass - * @return - */ - private JClass retrieveDecoratedExpectedClass(DeclaredType declaredType, TypeElement typeElement) { - String classTypeBaseName = typeElement.toString(); - - // Looking for basic java.util interfaces to set a default - // implementation - String decoratedClassName = null; - - if (typeElement.getKind() == ElementKind.INTERFACE) { - if (classTypeBaseName.equals(CanonicalNameConstants.MAP)) { - decoratedClassName = LinkedHashMap.class.getCanonicalName(); - } else if (classTypeBaseName.equals(CanonicalNameConstants.SET)) { - decoratedClassName = TreeSet.class.getCanonicalName(); - } else if (classTypeBaseName.equals(CanonicalNameConstants.LIST)) { - decoratedClassName = ArrayList.class.getCanonicalName(); - } else if (classTypeBaseName.equals(CanonicalNameConstants.COLLECTION)) { - decoratedClassName = ArrayList.class.getCanonicalName(); - } - } else { - decoratedClassName = typeElement.getQualifiedName().toString(); - } - - if (decoratedClassName != null) { - // Configure the super class of the final decorated class - String decoratedClassNameSuffix = ""; - JClass decoratedSuperClass = holder.refClass(decoratedClassName); - for (TypeMirror typeArgument : declaredType.getTypeArguments()) { - if (typeArgument instanceof WildcardType) { - WildcardType wildcardType = (WildcardType) typeArgument; - if (wildcardType.getExtendsBound() != null) { - typeArgument = wildcardType.getExtendsBound(); - } else if (wildcardType.getSuperBound() != null) { - typeArgument = wildcardType.getSuperBound(); - } - } - JClass narrowJClass = helper.typeMirrorToJClass(typeArgument, holder); - decoratedSuperClass = decoratedSuperClass.narrow(narrowJClass); - decoratedClassNameSuffix += plainName(narrowJClass); - } - - String decoratedFinalClassName = classTypeBaseName + "_" + decoratedClassNameSuffix; - decoratedFinalClassName = decoratedFinalClassName.replaceAll("\\[\\]", "s"); - decoratedFinalClassName = restClientPackage.name() + "." + decoratedFinalClassName; - JDefinedClass decoratedJClass = holder.definedClass(decoratedFinalClassName); - decoratedJClass._extends(decoratedSuperClass); - - return decoratedJClass; - } - - // Try to find the superclass and make a recursive call to the this - // method - TypeMirror enclosingSuperJClass = typeElement.getSuperclass(); - if (enclosingSuperJClass != null && enclosingSuperJClass.getKind() == TypeKind.DECLARED) { - DeclaredType declaredEnclosingSuperJClass = (DeclaredType) enclosingSuperJClass; - return retrieveDecoratedExpectedClass(declaredType, (TypeElement) declaredEnclosingSuperJClass.asElement()); - } - - // Falling back to the current enclosingJClass if Class can't be found - return null; - } - - protected String plainName(JClass jClass) { - String plainName = jClass.erasure().name(); - List typeParameters = jClass.getTypeParameters(); - if (typeParameters.size() > 0) { - plainName += "_"; - for (JClass typeParameter : typeParameters) { - plainName += plainName(typeParameter); - } - } - return plainName; - } - - @Override - protected JInvocation addHttpEntityVar(JInvocation restCall, MethodProcessorHolder methodHolder) { - return restCall.arg(generateHttpEntityVar(methodHolder)); - } - - @Override - protected JInvocation addResponseEntityArg(JInvocation restCall, MethodProcessorHolder methodHolder) { - JClass expectedClass = methodHolder.getExpectedClass(); - - if (expectedClass != null) { - return restCall.arg(expectedClass.dotclass()); - } else { - return restCall.arg(JExpr._null()); - } - } - - @Override - protected JInvocation addResultCallMethod(JInvocation restCall, MethodProcessorHolder methodHolder) { - JClass generatedReturnType = methodHolder.getMethodReturnClass(); - if (generatedReturnType == null) { - return restCall; - } - - if (!generatedReturnType.fullName().startsWith(CanonicalNameConstants.RESPONSE_ENTITY)) { - restCall = JExpr.invoke(restCall, "getBody"); - } - - return restCall; - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/GetProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/GetProcessor.java deleted file mode 100644 index d1c0e766a3..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/GetProcessor.java +++ /dev/null @@ -1,72 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.rest; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; - -import org.androidannotations.annotations.rest.Get; -import org.androidannotations.helper.CanonicalNameConstants; -import org.androidannotations.processing.EBeanHolder; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JExpression; -import com.sun.codemodel.JInvocation; -import com.sun.codemodel.JVar; - -public class GetProcessor extends GetPostProcessor { - - public GetProcessor(ProcessingEnvironment processingEnv, RestImplementationsHolder restImplementationHolder) { - super(processingEnv, restImplementationHolder); - } - - @Override - public String getTarget() { - return Get.class.getName(); - } - - @Override - public String retrieveUrlSuffix(Element element) { - Get getAnnotation = element.getAnnotation(Get.class); - return getAnnotation.value(); - } - - @Override - protected JExpression generateHttpEntityVar(MethodProcessorHolder methodHolder) { - ExecutableElement executableElement = (ExecutableElement) methodHolder.getElement(); - EBeanHolder holder = methodHolder.getHolder(); - JClass httpEntity = holder.refClass(CanonicalNameConstants.HTTP_ENTITY); - - JBlock body = methodHolder.getBody(); - JVar httpHeadersVar = generateHttpHeadersVar(holder, body, executableElement); - - boolean hasHeaders = httpHeadersVar != null; - - if (hasHeaders) { - JInvocation newHttpEntityVarCall = JExpr._new(httpEntity.narrow(Object.class)); - newHttpEntityVarCall.arg(httpHeadersVar); - - String httpEntityVarName = "requestEntity"; - - return body.decl(httpEntity.narrow(Object.class), httpEntityVarName, newHttpEntityVarCall); - } else { - return JExpr._null(); - } - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/HeadProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/HeadProcessor.java deleted file mode 100644 index 5770b75838..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/HeadProcessor.java +++ /dev/null @@ -1,62 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.rest; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.type.TypeMirror; - -import org.androidannotations.annotations.rest.Head; -import org.androidannotations.processing.EBeanHolder; - -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JInvocation; - -public class HeadProcessor extends MethodProcessor { - - public HeadProcessor(ProcessingEnvironment processingEnv, RestImplementationsHolder restImplementationsHolder) { - super(processingEnv, restImplementationsHolder); - } - - @Override - public String getTarget() { - return Head.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) throws Exception { - - ExecutableElement executableElement = (ExecutableElement) element; - - TypeMirror returnType = executableElement.getReturnType(); - - JClass expectedClass = holder.refClass(returnType.toString()); - - Head headAnnotation = element.getAnnotation(Head.class); - String urlSuffix = headAnnotation.value(); - - generateRestTemplateCallBlock(new MethodProcessorHolder(holder, executableElement, urlSuffix, expectedClass, expectedClass, codeModel)); - } - - @Override - protected JInvocation addResultCallMethod(JInvocation restCall, MethodProcessorHolder methodHolder) { - return JExpr.invoke(restCall, "getHeaders"); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/MethodProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/MethodProcessor.java deleted file mode 100644 index a357fe98be..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/MethodProcessor.java +++ /dev/null @@ -1,270 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.rest; - -import java.util.HashMap; -import java.util.List; -import java.util.Locale; -import java.util.Map; -import java.util.Set; -import java.util.TreeMap; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.VariableElement; - -import org.androidannotations.annotations.rest.Accept; -import org.androidannotations.helper.APTCodeModelHelper; -import org.androidannotations.helper.CanonicalNameConstants; -import org.androidannotations.helper.RestAnnotationHelper; -import org.androidannotations.processing.DecoratingElementProcessor; -import org.androidannotations.processing.EBeanHolder; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -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.JType; -import com.sun.codemodel.JVar; - -public abstract class MethodProcessor implements DecoratingElementProcessor { - - protected final RestImplementationsHolder restImplementationsHolder; - protected final RestAnnotationHelper restAnnotationHelper; - protected final APTCodeModelHelper helper = new APTCodeModelHelper(); - - public MethodProcessor(ProcessingEnvironment processingEnv, RestImplementationsHolder restImplementationsHolder) { - this.restImplementationsHolder = restImplementationsHolder; - restAnnotationHelper = new RestAnnotationHelper(processingEnv, getTarget()); - } - - protected void generateRestTemplateCallBlock(MethodProcessorHolder methodHolder) { - RestImplementationHolder holder = restImplementationsHolder.getEnclosingHolder(methodHolder.getElement()); - ExecutableElement executableElement = (ExecutableElement) methodHolder.getElement(); - EBeanHolder eBeanHolder = methodHolder.getHolder(); - JClass expectedClass = methodHolder.getExpectedClass(); - JClass methodReturnClass = methodHolder.getMethodReturnClass(); - - // Creating method signature - JMethod method; - String methodName = executableElement.getSimpleName().toString(); - boolean methodReturnVoid = methodReturnClass == null && expectedClass == null; - if (methodReturnVoid) { - method = holder.restImplementationClass.method(JMod.PUBLIC, void.class, methodName); - } else { - method = holder.restImplementationClass.method(JMod.PUBLIC, methodHolder.getMethodReturnClass(), methodName); - } - method.annotate(Override.class); - - // Keep a reference on method's body - JBlock body = method.body(); - methodHolder.setBody(body); - - // Keep a reference on method's parameters - TreeMap methodParams = extractMethodParamsVar(eBeanHolder, method, executableElement, holder); - methodHolder.setMethodParams(methodParams); - - // RestTemplate exchange() method call - JInvocation restCall = JExpr.invoke(holder.restTemplateField, "exchange"); - - // RestTemplate exchange() 1st arg : concat root url + suffix - JInvocation concatCall = JExpr.invoke(holder.rootUrlField, "concat"); - - // RestTemplate exchange() 2nd arg : add url param - restCall.arg(concatCall.arg(JExpr.lit(methodHolder.getUrlSuffix()))); - - // RestTemplate exchange() 3rd arg : add HttpMethod type param - JClass httpMethod = eBeanHolder.refClass(CanonicalNameConstants.HTTP_METHOD); - - // add method type param - String simpleName = getTarget().substring(getTarget().lastIndexOf('.') + 1); - String restMethodInCapitalLetters = simpleName.toUpperCase(Locale.ENGLISH); - - restCall.arg(httpMethod.staticRef(restMethodInCapitalLetters)); - - JVar hashMapVar = generateHashMapVar(methodHolder); - - restCall = addHttpEntityVar(restCall, methodHolder); - restCall = addResponseEntityArg(restCall, methodHolder); - - if (hashMapVar != null) { - restCall.arg(hashMapVar); - } - - insertRestCallInBody(body, restCall, methodHolder, methodReturnVoid); - } - - /** - * Add the HttpEntity attribute to restTemplate.exchange() method. By - * default, the value will be null (for DELETE, HEAD and - * OPTIONS method type) - */ - protected JInvocation addHttpEntityVar(JInvocation restCall, MethodProcessorHolder methodHolder) { - return restCall.arg(JExpr._null()); - } - - /** - * Add the response type to restTemplate.exchange() method. This is used to - * bind the response into a specific Java object. - */ - protected JInvocation addResponseEntityArg(JInvocation restCall, MethodProcessorHolder methodHolder) { - return restCall.arg(JExpr._null()); - } - - /** - * Add an extra method calls on the result of restTemplate.exchange(). By - * default, just return the result - */ - protected JInvocation addResultCallMethod(JInvocation restCall, MethodProcessorHolder methodHolder) { - return restCall; - } - - private void insertRestCallInBody(JBlock body, JInvocation restCall, MethodProcessorHolder methodHolder, boolean methodReturnVoid) { - if (methodReturnVoid) { - body.add(restCall); - } else { - restCall = addResultCallMethod(restCall, methodHolder); - body._return(restCall); - } - } - - private JVar generateHashMapVar(MethodProcessorHolder methodHolder) { - ExecutableElement element = (ExecutableElement) methodHolder.getElement(); - JCodeModel codeModel = methodHolder.getCodeModel(); - JBlock body = methodHolder.getBody(); - Map methodParams = methodHolder.getMethodParams(); - JVar hashMapVar = null; - - Set urlVariables = restAnnotationHelper.extractUrlVariableNames(element); - JClass hashMapClass = codeModel.ref(HashMap.class).narrow(String.class, Object.class); - if (!urlVariables.isEmpty()) { - hashMapVar = body.decl(hashMapClass, "urlVariables", JExpr._new(hashMapClass)); - - for (String urlVariable : urlVariables) { - JVar urlValue = methodParams.get(urlVariable); - body.invoke(hashMapVar, "put").arg(urlVariable).arg(urlValue); - methodParams.remove(urlVariable); - } - } - return hashMapVar; - } - - protected JExpression generateHttpEntityVar(MethodProcessorHolder methodHolder) { - ExecutableElement executableElement = (ExecutableElement) methodHolder.getElement(); - EBeanHolder holder = methodHolder.getHolder(); - JClass httpEntity = holder.refClass(CanonicalNameConstants.HTTP_ENTITY); - JInvocation newHttpEntityVarCall; - - TreeMap methodParams = methodHolder.getMethodParams(); - JVar entitySentToServer = null; - JType entityType = null; - if (!methodParams.isEmpty()) { - entitySentToServer = methodParams.firstEntry().getValue(); - entityType = entitySentToServer.type(); - } - - if (entitySentToServer != null) { - if (entityType.isPrimitive()) { - // Don't narrow primitive types... - entityType = entityType.boxify(); - } - newHttpEntityVarCall = JExpr._new(httpEntity.narrow(entityType)); - } else { - newHttpEntityVarCall = JExpr._new(httpEntity.narrow(Object.class)); - } - - JBlock body = methodHolder.getBody(); - JVar httpHeadersVar = generateHttpHeadersVar(holder, body, executableElement); - - boolean hasHeaders = httpHeadersVar != null; - - if (entitySentToServer != null) { - newHttpEntityVarCall.arg(entitySentToServer); - } - - if (hasHeaders) { - newHttpEntityVarCall.arg(httpHeadersVar); - } else if (methodParams.isEmpty()) { - newHttpEntityVarCall.arg(JExpr._null()); - } - - JVar httpEntityVar; - String httpEntityVarName = "requestEntity"; - if (entitySentToServer != null) { - httpEntityVar = body.decl(httpEntity.narrow(entityType), httpEntityVarName, newHttpEntityVarCall); - } else { - httpEntityVar = body.decl(httpEntity.narrow(Object.class), httpEntityVarName, newHttpEntityVarCall); - } - - return httpEntityVar; - } - - protected JVar generateHttpHeadersVar(EBeanHolder holder, JBlock body, ExecutableElement executableElement) { - JVar httpHeadersVar = null; - - JClass httpHeadersClass = holder.refClass(CanonicalNameConstants.HTTP_HEADERS); - - String mediaType = retrieveAcceptAnnotationValue(executableElement); - boolean hasMediaTypeDefined = mediaType != null; - if (hasMediaTypeDefined) { - httpHeadersVar = body.decl(httpHeadersClass, "httpHeaders", JExpr._new(httpHeadersClass)); - - JClass collectionsClass = holder.refClass(CanonicalNameConstants.COLLECTIONS); - JClass mediaTypeClass = holder.refClass(CanonicalNameConstants.MEDIA_TYPE); - - JInvocation mediaTypeListParam = collectionsClass.staticInvoke("singletonList").arg(mediaTypeClass.staticInvoke("parseMediaType").arg(mediaType)); - body.add(JExpr.invoke(httpHeadersVar, "setAccept").arg(mediaTypeListParam)); - } - - return httpHeadersVar; - } - - private String retrieveAcceptAnnotationValue(ExecutableElement executableElement) { - Accept acceptAnnotation = executableElement.getAnnotation(Accept.class); - if (acceptAnnotation == null) { - acceptAnnotation = executableElement.getEnclosingElement().getAnnotation(Accept.class); - } - if (acceptAnnotation != null) { - return acceptAnnotation.value(); - } else { - return null; - } - } - - private TreeMap extractMethodParamsVar(EBeanHolder eBeanHolder, JMethod method, ExecutableElement executableElement, RestImplementationHolder holder) { - List params = executableElement.getParameters(); - TreeMap methodParams = new TreeMap(); - for (VariableElement parameter : params) { - String paramName = parameter.getSimpleName().toString(); - String paramType = parameter.asType().toString(); - - JVar param = null; - if (parameter.asType().getKind().isPrimitive()) { - param = method.param(JType.parse(eBeanHolder.codeModel(), paramType), paramName); - } else { - JClass parameterClass = helper.typeMirrorToJClass(parameter.asType(), eBeanHolder); - param = method.param(parameterClass, paramName); - } - methodParams.put(paramName, param); - } - - return methodParams; - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/MethodProcessorHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/MethodProcessorHolder.java deleted file mode 100644 index 7f714b1b07..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/MethodProcessorHolder.java +++ /dev/null @@ -1,97 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.rest; - -import java.util.TreeMap; - -import javax.lang.model.element.Element; - -import org.androidannotations.processing.EBeanHolder; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JVar; - -public class MethodProcessorHolder { - - private Element element; - private String urlSuffix; - private JClass expectedClass; - private JClass methodReturnClass; - private JCodeModel codeModel; - - private JBlock body; - private TreeMap methodParams; - private final EBeanHolder holder; - - public MethodProcessorHolder(EBeanHolder holder, Element element, String urlSuffix, JClass expectedClass, JClass generatedReturnType, JCodeModel codeModel) { - this.holder = holder; - this.element = element; - this.urlSuffix = urlSuffix; - this.expectedClass = expectedClass; - this.methodReturnClass = generatedReturnType; - this.codeModel = codeModel; - } - - public Element getElement() { - return element; - } - - public String getUrlSuffix() { - return urlSuffix; - } - - public JClass getExpectedClass() { - return expectedClass; - } - - public void setExpectedClass(JClass expectedClass) { - this.expectedClass = expectedClass; - } - - public JClass getMethodReturnClass() { - return methodReturnClass; - } - - public void setMethodReturnClass(JClass methodReturnClass) { - this.methodReturnClass = methodReturnClass; - } - - public JCodeModel getCodeModel() { - return codeModel; - } - - public JBlock getBody() { - return body; - } - - public void setBody(JBlock body) { - this.body = body; - } - - public TreeMap getMethodParams() { - return methodParams; - } - - public void setMethodParams(TreeMap methodParams) { - this.methodParams = methodParams; - } - - public EBeanHolder getHolder() { - return holder; - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/OptionsProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/OptionsProcessor.java deleted file mode 100644 index e2f93a1dfe..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/OptionsProcessor.java +++ /dev/null @@ -1,72 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.rest; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.type.DeclaredType; -import javax.lang.model.type.TypeMirror; - -import org.androidannotations.annotations.rest.Options; -import org.androidannotations.helper.CanonicalNameConstants; -import org.androidannotations.processing.EBeanHolder; - -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JInvocation; - -public class OptionsProcessor extends MethodProcessor { - - public OptionsProcessor(ProcessingEnvironment processingEnv, RestImplementationsHolder restImplementationsHolder) { - super(processingEnv, restImplementationsHolder); - } - - @Override - public String getTarget() { - return Options.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) throws Exception { - - ExecutableElement executableElement = (ExecutableElement) element; - - TypeMirror returnType = executableElement.getReturnType(); - - DeclaredType declaredReturnType = (DeclaredType) returnType; - - TypeMirror typeParameter = declaredReturnType.getTypeArguments().get(0); - - JClass expectedClass = holder.refClass(typeParameter.toString()); - - JClass generatedReturnType = holder.refClass(CanonicalNameConstants.SET).narrow(expectedClass); - - Options optionsAnnotation = element.getAnnotation(Options.class); - String urlSuffix = optionsAnnotation.value(); - - generateRestTemplateCallBlock(new MethodProcessorHolder(holder, executableElement, urlSuffix, expectedClass, generatedReturnType, codeModel)); - } - - @Override - protected JInvocation addResultCallMethod(JInvocation restCall, MethodProcessorHolder methodHolder) { - restCall = JExpr.invoke(restCall, "getHeaders"); - restCall = JExpr.invoke(restCall, "getAllow"); - return restCall; - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/PostProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/PostProcessor.java deleted file mode 100644 index 7707b3c746..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/PostProcessor.java +++ /dev/null @@ -1,40 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.rest; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; - -import org.androidannotations.annotations.rest.Post; - -public class PostProcessor extends GetPostProcessor { - - public PostProcessor(ProcessingEnvironment processingEnv, RestImplementationsHolder restImplementationHolder) { - super(processingEnv, restImplementationHolder); - } - - @Override - public String getTarget() { - return Post.class.getName(); - } - - @Override - public String retrieveUrlSuffix(Element element) { - Post getAnnotation = element.getAnnotation(Post.class); - return getAnnotation.value(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/PutProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/PutProcessor.java deleted file mode 100644 index c65d08f4b7..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/PutProcessor.java +++ /dev/null @@ -1,55 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.rest; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; - -import org.androidannotations.annotations.rest.Put; -import org.androidannotations.processing.EBeanHolder; - -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JInvocation; - -public class PutProcessor extends MethodProcessor { - - public PutProcessor(ProcessingEnvironment processingEnv, RestImplementationsHolder restImplementationsHolder) { - super(processingEnv, restImplementationsHolder); - } - - @Override - public String getTarget() { - return Put.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeanHolder holder) throws Exception { - - ExecutableElement executableElement = (ExecutableElement) element; - - Put putAnnotation = element.getAnnotation(Put.class); - String urlSuffix = putAnnotation.value(); - - generateRestTemplateCallBlock(new MethodProcessorHolder(holder, executableElement, urlSuffix, null, null, codeModel)); - } - - @Override - protected JInvocation addHttpEntityVar(JInvocation restCall, MethodProcessorHolder methodHolder) { - return restCall.arg(generateHttpEntityVar(methodHolder)); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/RestImplementationHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/RestImplementationHolder.java deleted file mode 100644 index 7ced7511a8..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/RestImplementationHolder.java +++ /dev/null @@ -1,29 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.rest; - -import com.sun.codemodel.JDefinedClass; -import com.sun.codemodel.JFieldVar; - -public class RestImplementationHolder { - - public JDefinedClass restImplementationClass; - - public JFieldVar restTemplateField; - - public JFieldVar rootUrlField; - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/RestImplementationsHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/RestImplementationsHolder.java deleted file mode 100644 index f0d07bcbf5..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/RestImplementationsHolder.java +++ /dev/null @@ -1,42 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.rest; - -import java.util.HashMap; -import java.util.Map; - -import javax.lang.model.element.Element; - -public class RestImplementationsHolder { - - private Map holders = new HashMap(); - - public RestImplementationHolder create(Element element) { - RestImplementationHolder holder = new RestImplementationHolder(); - holders.put(element, holder); - return holder; - } - - public RestImplementationHolder getEnclosingHolder(Element enclosedElement) { - Element activityElement = enclosedElement.getEnclosingElement(); - return holders.get(activityElement); - } - - public RestImplementationHolder getRelativeHolder(Element element) { - return holders.get(element); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/RestProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/RestProcessor.java deleted file mode 100644 index b0f49bcc1b..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/rest/RestProcessor.java +++ /dev/null @@ -1,188 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.rest; - -import static com.sun.codemodel.JExpr._new; -import static com.sun.codemodel.JExpr._this; -import static com.sun.codemodel.JExpr.invoke; -import static com.sun.codemodel.JExpr.lit; -import static org.androidannotations.helper.CanonicalNameConstants.ARRAYLIST; -import static org.androidannotations.helper.CanonicalNameConstants.CLIENT_HTTP_REQUEST_INTERCEPTOR; -import static org.androidannotations.helper.CanonicalNameConstants.REST_TEMPLATE; -import static org.androidannotations.helper.CanonicalNameConstants.STRING; - -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.TypeElement; -import javax.lang.model.element.VariableElement; -import javax.lang.model.type.DeclaredType; -import javax.lang.model.type.TypeKind; -import javax.lang.model.util.ElementFilter; - -import org.androidannotations.annotations.rest.Rest; -import org.androidannotations.helper.AnnotationHelper; -import org.androidannotations.helper.ModelConstants; -import org.androidannotations.processing.EBeansHolder; -import org.androidannotations.processing.GeneratingElementProcessor; - -import com.sun.codemodel.ClassType; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JMod; -import com.sun.codemodel.JVar; - -public class RestProcessor implements GeneratingElementProcessor { - - private final RestImplementationsHolder restImplementationsHolder; - private AnnotationHelper annotationHelper; - - public RestProcessor(ProcessingEnvironment processingEnv, RestImplementationsHolder restImplementationsHolder) { - annotationHelper = new AnnotationHelper(processingEnv); - this.restImplementationsHolder = restImplementationsHolder; - } - - @Override - public String getTarget() { - return Rest.class.getName(); - } - - @Override - public void process(Element element, JCodeModel codeModel, EBeansHolder eBeansHolder) throws Exception { - - RestImplementationHolder holder = restImplementationsHolder.create(element); - - TypeElement typeElement = (TypeElement) element; - String interfaceName = typeElement.getQualifiedName().toString(); - - String implementationName = interfaceName + ModelConstants.GENERATION_SUFFIX; - - holder.restImplementationClass = codeModel._class(JMod.PUBLIC, implementationName, ClassType.CLASS); - eBeansHolder.create(element, Rest.class, holder.restImplementationClass); - - JClass interfaceClass = eBeansHolder.refClass(interfaceName); - holder.restImplementationClass._implements(interfaceClass); - - // RestTemplate field - JClass restTemplateClass = eBeansHolder.refClass(REST_TEMPLATE); - holder.restTemplateField = holder.restImplementationClass.field(JMod.PRIVATE, restTemplateClass, "restTemplate"); - - // RootUrl field - JClass stringClass = eBeansHolder.refClass(STRING); - holder.rootUrlField = holder.restImplementationClass.field(JMod.PRIVATE, stringClass, "rootUrl"); - - { - // Constructor - JMethod constructor = holder.restImplementationClass.constructor(JMod.PUBLIC); - JBlock constructorBody = constructor.body(); - constructorBody.assign(holder.restTemplateField, _new(restTemplateClass)); - - { - // Converters - List converters = annotationHelper.extractAnnotationClassArrayParameter(element, getTarget(), "converters"); - for (DeclaredType converterType : converters) { - JClass converterClass = eBeansHolder.refClass(converterType.toString()); - constructorBody.add(invoke(holder.restTemplateField, "getMessageConverters").invoke("add").arg(_new(converterClass))); - } - } - - { - // Interceptors - List interceptors = annotationHelper.extractAnnotationClassArrayParameter(element, getTarget(), "interceptors"); - if (interceptors != null) { - JClass listClass = eBeansHolder.refClass(ARRAYLIST); - JClass clientInterceptorClass = eBeansHolder.refClass(CLIENT_HTTP_REQUEST_INTERCEPTOR); - listClass = listClass.narrow(clientInterceptorClass); - constructorBody.add(invoke(holder.restTemplateField, "setInterceptors").arg(_new(listClass))); - for (DeclaredType interceptorType : interceptors) { - JClass interceptorClass = eBeansHolder.refClass(interceptorType.toString()); - constructorBody.add(invoke(holder.restTemplateField, "getInterceptors").invoke("add").arg(_new(interceptorClass))); - } - } - } - constructorBody.assign(holder.rootUrlField, lit(typeElement.getAnnotation(Rest.class).rootUrl())); - } - - // Implement getRestTemplate method - List enclosedElements = typeElement.getEnclosedElements(); - List methods = ElementFilter.methodsIn(enclosedElements); - for (ExecutableElement method : methods) { - if (method.getParameters().size() == 0 && method.getReturnType().toString().equals(REST_TEMPLATE)) { - String methodName = method.getSimpleName().toString(); - JMethod getRestTemplateMethod = holder.restImplementationClass.method(JMod.PUBLIC, restTemplateClass, methodName); - getRestTemplateMethod.annotate(Override.class); - getRestTemplateMethod.body()._return(holder.restTemplateField); - break; // Only one implementation - } - } - - for (ExecutableElement method : methods) { - List parameters = method.getParameters(); - if (parameters.size() == 1 && method.getReturnType().getKind() == TypeKind.VOID) { - VariableElement firstParameter = parameters.get(0); - if (firstParameter.asType().toString().equals(REST_TEMPLATE)) { - String methodName = method.getSimpleName().toString(); - JMethod setRestTemplateMethod = holder.restImplementationClass.method(JMod.PUBLIC, codeModel.VOID, methodName); - setRestTemplateMethod.annotate(Override.class); - - JVar restTemplateSetterParam = setRestTemplateMethod.param(restTemplateClass, firstParameter.getSimpleName().toString()); - - setRestTemplateMethod.body().assign(_this().ref(holder.restTemplateField), restTemplateSetterParam); - break; // Only one implementation - } - } - } - - // Implement getRootUrl method - implementGetRootUrl(holder, eBeansHolder, methods); - - // Implement setRootUrl method - for (ExecutableElement method : methods) { - List parameters = method.getParameters(); - if (parameters.size() == 1 && method.getReturnType().getKind() == TypeKind.VOID) { - VariableElement firstParameter = parameters.get(0); - if (firstParameter.asType().toString().equals(STRING) && method.getSimpleName().toString().equals("setRootUrl")) { - JMethod setRootUrlMethod = holder.restImplementationClass.method(JMod.PUBLIC, codeModel.VOID, method.getSimpleName().toString()); - setRootUrlMethod.annotate(Override.class); - - JVar rootUrlSetterParam = setRootUrlMethod.param(stringClass, firstParameter.getSimpleName().toString()); - - setRootUrlMethod.body().assign(_this().ref(holder.rootUrlField), rootUrlSetterParam); - break; // Only one implementation - } - } - } - - } - - private void implementGetRootUrl(RestImplementationHolder holder, EBeansHolder eBeansHolder, List methods) { - for (ExecutableElement method : methods) { - String methodName = method.getSimpleName().toString(); - - if (method.getParameters().size() == 0 && method.getReturnType().toString().equals(STRING) && methodName.equals("getRootUrl")) { - JMethod getRootUrlMethod = holder.restImplementationClass.method(JMod.PUBLIC, eBeansHolder.refClass(STRING), methodName); - - getRootUrlMethod.annotate(Override.class); - getRootUrlMethod.body()._return(holder.rootUrlField); - return; // Only one implementation - } - } - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/CoumpoundInnerClass.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/CoumpoundInnerClass.java index 721793c842..5d5a2d1d0e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/CoumpoundInnerClass.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/CoumpoundInnerClass.java @@ -15,9 +15,8 @@ */ package org.androidannotations.rclass; -import org.androidannotations.holder.GeneratedClassHolder; -import org.androidannotations.processing.EBeanHolder; import com.sun.codemodel.JFieldRef; +import org.androidannotations.holder.GeneratedClassHolder; public class CoumpoundInnerClass implements IRInnerClass { @@ -66,15 +65,6 @@ public JFieldRef getIdStaticRef(Integer idValue, GeneratedClassHolder holder) { return idStaticRef; } - @Override - public JFieldRef getIdStaticRef(Integer idValue, EBeanHolder holder) { - JFieldRef idStaticRef = rInnerClass.getIdStaticRef(idValue, holder); - if (idStaticRef == null) { - idStaticRef = androidRInnerClass.getIdStaticRef(idValue, holder); - } - return idStaticRef; - } - @Override public JFieldRef getIdStaticRef(String name, GeneratedClassHolder holder) { JFieldRef idStaticRef = rInnerClass.getIdStaticRef(name, holder); @@ -83,13 +73,4 @@ public JFieldRef getIdStaticRef(String name, GeneratedClassHolder holder) { } return idStaticRef; } - - @Override - public JFieldRef getIdStaticRef(String name, EBeanHolder holder) { - JFieldRef idStaticRef = rInnerClass.getIdStaticRef(name, holder); - if (idStaticRef == null) { - idStaticRef = androidRInnerClass.getIdStaticRef(name, holder); - } - return idStaticRef; - } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/IRInnerClass.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/IRInnerClass.java index 5652ed6279..89273c2985 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/IRInnerClass.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/IRInnerClass.java @@ -17,7 +17,6 @@ import com.sun.codemodel.JFieldRef; import org.androidannotations.holder.GeneratedClassHolder; -import org.androidannotations.processing.EBeanHolder; public interface IRInnerClass { @@ -31,12 +30,8 @@ public interface IRInnerClass { JFieldRef getIdStaticRef(Integer idValue, GeneratedClassHolder holder); - JFieldRef getIdStaticRef(Integer idValue, EBeanHolder holder); - JFieldRef getIdStaticRef(String name, GeneratedClassHolder holder); - JFieldRef getIdStaticRef(String name, EBeanHolder holder); - final IRInnerClass EMPTY_R_INNER_CLASS = new RInnerClass(null); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/RInnerClass.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/RInnerClass.java index 2f0f2d674d..7a27b1011f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/RInnerClass.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/RInnerClass.java @@ -19,7 +19,6 @@ import com.sun.codemodel.JFieldRef; import org.androidannotations.helper.CaseHelper; import org.androidannotations.holder.GeneratedClassHolder; -import org.androidannotations.processing.EBeanHolder; import javax.lang.model.element.Element; import javax.lang.model.element.TypeElement; @@ -105,24 +104,12 @@ public JFieldRef getIdStaticRef(Integer idValue, GeneratedClassHolder holder) { return extractIdStaticRef(holder, layoutFieldQualifiedName); } - @Override - public JFieldRef getIdStaticRef(Integer idValue, EBeanHolder holder) { - String layoutFieldQualifiedName = getIdQualifiedName(idValue); - return extractIdStaticRef(holder, layoutFieldQualifiedName); - } - @Override public JFieldRef getIdStaticRef(String name, GeneratedClassHolder holder) { String layoutFieldQualifiedName = getIdQualifiedName(name); return extractIdStaticRef(holder, layoutFieldQualifiedName); } - @Override - public JFieldRef getIdStaticRef(String name, EBeanHolder holder) { - String layoutFieldQualifiedName = getIdQualifiedName(name); - return extractIdStaticRef(holder, layoutFieldQualifiedName); - } - public static JFieldRef extractIdStaticRef(GeneratedClassHolder holder, String layoutFieldQualifiedName) { if (layoutFieldQualifiedName != null) { int fieldSuffix = layoutFieldQualifiedName.lastIndexOf('.'); @@ -135,18 +122,4 @@ public static JFieldRef extractIdStaticRef(GeneratedClassHolder holder, String l return null; } } - - public static JFieldRef extractIdStaticRef(EBeanHolder holder, String layoutFieldQualifiedName) { - if (layoutFieldQualifiedName != null) { - int fieldSuffix = layoutFieldQualifiedName.lastIndexOf('.'); - String fieldName = layoutFieldQualifiedName.substring(fieldSuffix + 1); - String rInnerClassName = layoutFieldQualifiedName.substring(0, fieldSuffix); - - JClass refClass = holder.refClass(rInnerClassName); - return refClass.staticRef(fieldName); - } else { - return null; - } - } - } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AbstractSeekBarTouchValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AbstractSeekBarTouchValidator.java deleted file mode 100644 index 46fd25057f..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AbstractSeekBarTouchValidator.java +++ /dev/null @@ -1,84 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.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 org.androidannotations.helper.CanonicalNameConstants; -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 abstract class AbstractSeekBarTouchValidator implements ElementValidator { - - private final IdValidatorHelper validatorHelper; - - private final IdAnnotationHelper annotationHelper; - - public AbstractSeekBarTouchValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @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); - - ExecutableElement executableElement = (ExecutableElement) element; - validatorHelper.returnTypeIsVoid(executableElement, valid); - - hasProgressChangeMethodParameters(executableElement, valid); - - return valid.isValid(); - } - - private void hasProgressChangeMethodParameters(ExecutableElement executableElement, IsValid valid) { - List parameters = executableElement.getParameters(); - - if (parameters.size() > 1) { - annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter declaration. You can only have one parameter of type " + CanonicalNameConstants.SEEKBAR + ". Try declaring " + executableElement.getSimpleName() + "(" + CanonicalNameConstants.SEEKBAR + " seekBar);"); - valid.invalidate(); - return; - } - - if (parameters.size() == 1) { - String parameterType = parameters.get(0).asType().toString(); - if (!parameterType.equals(CanonicalNameConstants.SEEKBAR)) { - annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter declaration. You can only have one parameter of type " + CanonicalNameConstants.SEEKBAR + ". Try declaring " + executableElement.getSimpleName() + "(" + CanonicalNameConstants.SEEKBAR + " seekBar);"); - valid.invalidate(); - } - } - - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AfterInjectValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AfterInjectValidator.java deleted file mode 100644 index 59e863f6c6..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AfterInjectValidator.java +++ /dev/null @@ -1,61 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.AfterInject; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class AfterInjectValidator implements ElementValidator { - - private ValidatorHelper validatorHelper; - - public AfterInjectValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return AfterInject.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); - - ExecutableElement executableElement = (ExecutableElement) element; - - validatorHelper.returnTypeIsVoid(executableElement, valid); - - validatorHelper.isNotPrivate(element, valid); - - validatorHelper.doesntThrowException(executableElement, valid); - - validatorHelper.param.zeroParameter(executableElement, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AfterTextChangeValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AfterTextChangeValidator.java deleted file mode 100644 index ceab3c7b30..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AfterTextChangeValidator.java +++ /dev/null @@ -1,98 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.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 org.androidannotations.annotations.AfterTextChange; -import org.androidannotations.helper.CanonicalNameConstants; -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 AfterTextChangeValidator implements ElementValidator { - - private final IdValidatorHelper validatorHelper; - - private final IdAnnotationHelper annotationHelper; - - public AfterTextChangeValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return AfterTextChange.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); - - ExecutableElement executableElement = (ExecutableElement) element; - validatorHelper.returnTypeIsVoid(executableElement, valid); - - haveAfterTextChangedMethodParameters(executableElement, valid); - - return valid.isValid(); - } - - private void haveAfterTextChangedMethodParameters(ExecutableElement executableElement, IsValid valid) { - List parameters = executableElement.getParameters(); - boolean editableParameterFound = false; - boolean textViewParameterFound = false; - for (VariableElement parameter : parameters) { - String parameterType = parameter.asType().toString(); - if (parameterType.equals(CanonicalNameConstants.EDITABLE)) { - if (editableParameterFound) { - annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter declaration. you can declare only one parameter of type android.text.Editable"); - valid.invalidate(); - } - editableParameterFound = true; - continue; - } - if (parameterType.equals(CanonicalNameConstants.TEXT_VIEW)) { - if (textViewParameterFound) { - annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter declaration. you can declare only one parameter of type android.widget.TextView"); - valid.invalidate(); - } - textViewParameterFound = true; - continue; - } - valid.invalidate(); - annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter type. %s can only have a android.widget.TextView parameter and/or an android.text.Editable parameter. See android.text.TextWatcher.afterTextChanged() for more informations."); - } - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AfterViewsValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AfterViewsValidator.java deleted file mode 100644 index 661b1daaa1..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AfterViewsValidator.java +++ /dev/null @@ -1,61 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.AfterViews; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class AfterViewsValidator implements ElementValidator { - - private ValidatorHelper validatorHelper; - - public AfterViewsValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return AfterViews.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); - - ExecutableElement executableElement = (ExecutableElement) element; - - validatorHelper.returnTypeIsVoid(executableElement, valid); - - validatorHelper.isNotPrivate(element, valid); - - validatorHelper.doesntThrowException(executableElement, valid); - - validatorHelper.param.zeroParameter(executableElement, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AppValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AppValidator.java deleted file mode 100644 index 60fc01757f..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/AppValidator.java +++ /dev/null @@ -1,54 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.App; -import org.androidannotations.annotations.EApplication; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class AppValidator implements ElementValidator { - - private ValidatorHelper validatorHelper; - - public AppValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return App.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - - validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); - - validatorHelper.typeHasAnnotation(EApplication.class, element, valid); - - validatorHelper.isNotPrivate(element, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/BeanValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/BeanValidator.java deleted file mode 100644 index 17bef42790..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/BeanValidator.java +++ /dev/null @@ -1,55 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.Bean; -import org.androidannotations.annotations.EBean; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class BeanValidator implements ElementValidator { - - private ValidatorHelper validatorHelper; - - public BeanValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return Bean.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); - - validatorHelper.isNotPrivate(element, valid); - - validatorHelper.typeOrTargetValueHasAnnotation(EBean.class, element, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/BeforeTextChangeValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/BeforeTextChangeValidator.java deleted file mode 100644 index 0465c7d56f..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/BeforeTextChangeValidator.java +++ /dev/null @@ -1,108 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.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 org.androidannotations.annotations.BeforeTextChange; -import org.androidannotations.helper.CanonicalNameConstants; -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 BeforeTextChangeValidator implements ElementValidator { - - private final IdValidatorHelper validatorHelper; - - private final IdAnnotationHelper annotationHelper; - - public BeforeTextChangeValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return BeforeTextChange.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); - - ExecutableElement executableElement = (ExecutableElement) element; - validatorHelper.returnTypeIsVoid(executableElement, valid); - - haveBeforeTextChangedMethodParameters(executableElement, valid); - - return valid.isValid(); - } - - private void haveBeforeTextChangedMethodParameters(ExecutableElement executableElement, IsValid valid) { - List parameters = executableElement.getParameters(); - boolean charSequenceParameterFound = false; - boolean textViewParameterFound = false; - for (VariableElement parameter : parameters) { - String parameterType = parameter.asType().toString(); - if (parameterType.equals(CanonicalNameConstants.CHAR_SEQUENCE)) { - if (charSequenceParameterFound) { - annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter declaration. you can declare only one parameter of type java.lang.CharSequence"); - valid.invalidate(); - } - charSequenceParameterFound = true; - continue; - } - if (parameterType.equals(CanonicalNameConstants.TEXT_VIEW)) { - if (textViewParameterFound) { - annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter declaration. you can declare only one parameter of type android.widget.TextView"); - valid.invalidate(); - } - textViewParameterFound = true; - continue; - } - if (parameter.asType().getKind() == TypeKind.INT || CanonicalNameConstants.INTEGER.equals(parameterType)) { - String parameterName = parameter.toString(); - if ("start".equals(parameterName) || "count".equals(parameterName) || "after".equals(parameterName)) { - continue; - } - annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter name. You can only have start, before, or count parameter name. Try to pick a parameter from android.text.TextWatcher.beforeTextChanged() method."); - valid.invalidate(); - continue; - } - annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter (" + parameter.toString() + "). %s can only have a android.widget.TextView parameter and/or parameters from android.text.TextWatcher.beforeTextChanged() method."); - valid.invalidate(); - } - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/CheckedChangeValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/CheckedChangeValidator.java deleted file mode 100644 index 49f853c7b5..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/CheckedChangeValidator.java +++ /dev/null @@ -1,72 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 deleted file mode 100644 index 8093cf3d26..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ClickValidator.java +++ /dev/null @@ -1,67 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.Click; -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 ClickValidator implements ElementValidator { - - private IdValidatorHelper validatorHelper; - - public ClickValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - IdAnnotationHelper annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return Click.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.zeroOrOneViewParameter(executableElement, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/CustomTitleValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/CustomTitleValidator.java deleted file mode 100644 index 7da9919775..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/CustomTitleValidator.java +++ /dev/null @@ -1,51 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.CustomTitle; -import org.androidannotations.helper.IdAnnotationHelper; -import org.androidannotations.helper.IdValidatorHelper; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.rclass.IRClass; - -public class CustomTitleValidator implements ElementValidator { - - private IdValidatorHelper validatorHelper; - - public CustomTitleValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - IdAnnotationHelper annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return CustomTitle.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - - validatorHelper.hasEActivity(element, validatedElements, valid); - - validatorHelper.resIdsExist(element, IRClass.Res.LAYOUT, IdValidatorHelper.FallbackStrategy.NEED_RES_ID, valid); - - return valid.isValid(); - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EActivityValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EActivityValidator.java deleted file mode 100644 index 595fcf7777..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EActivityValidator.java +++ /dev/null @@ -1,62 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.EActivity; -import org.androidannotations.helper.AndroidManifest; -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 EActivityValidator implements ElementValidator { - - private final IdValidatorHelper validatorHelper; - private final AndroidManifest androidManifest; - - public EActivityValidator(ProcessingEnvironment processingEnv, IRClass rClass, AndroidManifest androidManifest) { - this.androidManifest = androidManifest; - IdAnnotationHelper annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return EActivity.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.extendsActivity(element, valid); - - validatorHelper.resIdsExist(element, Res.LAYOUT, FallbackStrategy.ALLOW_NO_RES_ID, valid); - - validatorHelper.isNotFinal(element, valid); - - validatorHelper.componentRegistered(element, androidManifest, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EApplicationValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EApplicationValidator.java deleted file mode 100644 index c8980314b9..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EApplicationValidator.java +++ /dev/null @@ -1,57 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.EApplication; -import org.androidannotations.helper.AndroidManifest; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class EApplicationValidator implements ElementValidator { - - private final ValidatorHelper validatorHelper; - private final AndroidManifest androidManifest; - - public EApplicationValidator(ProcessingEnvironment processingEnv, AndroidManifest androidManifest) { - this.androidManifest = androidManifest; - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return EApplication.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.extendsApplication(element, valid); - - validatorHelper.isNotFinal(element, valid); - - validatorHelper.applicationRegistered(element, androidManifest, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EBeanValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EBeanValidator.java deleted file mode 100644 index dbdcc06796..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EBeanValidator.java +++ /dev/null @@ -1,54 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.EBean; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class EBeanValidator implements ElementValidator { - - private final ValidatorHelper validatorHelper; - - public EBeanValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return EBean.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.isNotFinal(element, valid); - - validatorHelper.isNotPrivate(element, valid); - - validatorHelper.hasEmptyOrContextConstructor(element, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EFragmentValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EFragmentValidator.java deleted file mode 100644 index 51dce216f5..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EFragmentValidator.java +++ /dev/null @@ -1,61 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.EFragment; -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 EFragmentValidator implements ElementValidator { - - private final IdValidatorHelper validatorHelper; - - public EFragmentValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - IdAnnotationHelper annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return EFragment.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.isNotFinal(element, valid); - - validatorHelper.resIdsExist(element, Res.LAYOUT, FallbackStrategy.ALLOW_NO_RES_ID, valid); - - validatorHelper.isNotPrivate(element, valid); - - validatorHelper.hasEmptyConstructor(element, valid); - - validatorHelper.extendsFragment(element, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EProviderValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EProviderValidator.java deleted file mode 100644 index 8584943cdf..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EProviderValidator.java +++ /dev/null @@ -1,57 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.EProvider; -import org.androidannotations.helper.AndroidManifest; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class EProviderValidator implements ElementValidator { - - private final ValidatorHelper validatorHelper; - private final AndroidManifest androidManifest; - - public EProviderValidator(ProcessingEnvironment processingEnv, AndroidManifest androidManifest) { - this.androidManifest = androidManifest; - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return EProvider.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.extendsProvider(element, valid); - - validatorHelper.isNotFinal(element, valid); - - validatorHelper.componentRegistered(element, androidManifest, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EReceiverValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EReceiverValidator.java deleted file mode 100644 index 39a7b707b6..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EReceiverValidator.java +++ /dev/null @@ -1,58 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.EReceiver; -import org.androidannotations.helper.AndroidManifest; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class EReceiverValidator implements ElementValidator { - - private final ValidatorHelper validatorHelper; - private final AndroidManifest androidManifest; - - public EReceiverValidator(ProcessingEnvironment processingEnv, AndroidManifest androidManifest) { - this.androidManifest = androidManifest; - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return EReceiver.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.extendsReceiver(element, valid); - - validatorHelper.isNotFinal(element, valid); - - final boolean NO_WARNING = false; - validatorHelper.componentRegistered(element, androidManifest, NO_WARNING, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EServiceValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EServiceValidator.java deleted file mode 100644 index 0ec10d7705..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EServiceValidator.java +++ /dev/null @@ -1,57 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.EService; -import org.androidannotations.helper.AndroidManifest; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class EServiceValidator implements ElementValidator { - - private final ValidatorHelper validatorHelper; - private final AndroidManifest androidManifest; - - public EServiceValidator(ProcessingEnvironment processingEnv, AndroidManifest androidManifest) { - this.androidManifest = androidManifest; - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return EService.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.extendsService(element, valid); - - validatorHelper.isNotFinal(element, valid); - - validatorHelper.componentRegistered(element, androidManifest, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EViewGroupValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EViewGroupValidator.java deleted file mode 100644 index d7443502d0..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EViewGroupValidator.java +++ /dev/null @@ -1,58 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.EViewGroup; -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 EViewGroupValidator implements ElementValidator { - - private final IdValidatorHelper validatorHelper; - private IdAnnotationHelper annotationHelper; - - public EViewGroupValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return EViewGroup.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.extendsViewGroup(element, valid); - - validatorHelper.resIdsExist(element, Res.LAYOUT, FallbackStrategy.ALLOW_NO_RES_ID, valid); - - validatorHelper.isNotFinal(element, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EViewValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EViewValidator.java deleted file mode 100644 index 2d8e8ac2c6..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/EViewValidator.java +++ /dev/null @@ -1,53 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.EView; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class EViewValidator implements ElementValidator { - - private final ValidatorHelper validatorHelper; - private TargetAnnotationHelper annotationHelper; - - public EViewValidator(ProcessingEnvironment processingEnv) { - annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return EView.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.extendsView(element, valid); - - validatorHelper.isNotFinal(element, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ElementValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ElementValidator.java deleted file mode 100644 index 24afca6b95..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ElementValidator.java +++ /dev/null @@ -1,37 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.lang.model.element.Element; - -import org.androidannotations.helper.HasTarget; -import org.androidannotations.model.AnnotationElements; - -public interface ElementValidator extends HasTarget { - - /** - * Method used to filter validated elements from annotated elements - * - * @param element - * the element to validate - * @param validatedElements - * to already validated elements - * @return true if the element should be added to the validatedElements, - * false otherwise - */ - boolean validate(Element element, AnnotationElements validatedElements); - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ExtraValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ExtraValidator.java deleted file mode 100644 index da565e9246..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ExtraValidator.java +++ /dev/null @@ -1,56 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.Extra; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class ExtraValidator implements ElementValidator { - - private ValidatorHelper validatorHelper; - - public ExtraValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return Extra.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - - /* - * TODO since we override setIntent(), we should check that the - * setIntent() method can be overridden - */ - - validatorHelper.enclosingElementHasEActivity(element, validatedElements, valid); - - validatorHelper.isNotPrivate(element, 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 deleted file mode 100644 index 6d6bbc6314..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FocusChangeValidator.java +++ /dev/null @@ -1,67 +0,0 @@ -/** - * Copyright (C) 2010-2013 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; - -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/FragmentArgValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FragmentArgValidator.java deleted file mode 100644 index 1b29a87a98..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FragmentArgValidator.java +++ /dev/null @@ -1,51 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.FragmentArg; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class FragmentArgValidator implements ElementValidator { - - private ValidatorHelper validatorHelper; - - public FragmentArgValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return FragmentArg.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - - validatorHelper.enclosingElementHasEFragment(element, validatedElements, valid); - - validatorHelper.isNotPrivate(element, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FragmentByIdValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FragmentByIdValidator.java deleted file mode 100644 index 09a8b7b00e..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FragmentByIdValidator.java +++ /dev/null @@ -1,60 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.FragmentById; -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 FragmentByIdValidator implements ElementValidator { - - private IdValidatorHelper validatorHelper; - private IdAnnotationHelper annotationHelper; - - public FragmentByIdValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return FragmentById.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); - - validatorHelper.extendsFragment(element, valid); - - validatorHelper.resIdsExist(element, Res.ID, FallbackStrategy.USE_ELEMENT_NAME, valid); - - validatorHelper.isNotPrivate(element, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FragmentByTagValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FragmentByTagValidator.java deleted file mode 100644 index eb96243017..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FragmentByTagValidator.java +++ /dev/null @@ -1,55 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.FragmentByTag; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class FragmentByTagValidator implements ElementValidator { - - private ValidatorHelper validatorHelper; - private TargetAnnotationHelper annotationHelper; - - public FragmentByTagValidator(ProcessingEnvironment processingEnv) { - annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return FragmentByTag.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); - - validatorHelper.extendsFragment(element, valid); - - validatorHelper.isNotPrivate(element, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FromHtmlValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FromHtmlValidator.java deleted file mode 100644 index 0c18290e55..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FromHtmlValidator.java +++ /dev/null @@ -1,57 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.FromHtml; -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 FromHtmlValidator implements ElementValidator { - - private IdValidatorHelper validatorHelper; - - public FromHtmlValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - IdAnnotationHelper annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return FromHtml.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.hasViewByIdAnnotation(element, validatedElements, valid); - - validatorHelper.extendsTextView(element, valid); - - validatorHelper.resIdsExist(element, Res.STRING, FallbackStrategy.USE_ELEMENT_NAME, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FullscreenValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FullscreenValidator.java deleted file mode 100644 index eaac1154c6..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/FullscreenValidator.java +++ /dev/null @@ -1,50 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.Fullscreen; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class FullscreenValidator implements ElementValidator { - - private ValidatorHelper validatorHelper; - - public FullscreenValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return Fullscreen.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.hasEActivity(element, validatedElements, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/HierarchyViewerSupportValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/HierarchyViewerSupportValidator.java deleted file mode 100644 index 3bc62d6112..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/HierarchyViewerSupportValidator.java +++ /dev/null @@ -1,57 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.HierarchyViewerSupport; -import org.androidannotations.helper.AndroidManifest; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class HierarchyViewerSupportValidator implements ElementValidator { - - private final ValidatorHelper validatorHelper; - private final AndroidManifest androidManifest; - - public HierarchyViewerSupportValidator(ProcessingEnvironment processingEnv, AndroidManifest androidManifest) { - this.androidManifest = androidManifest; - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return HierarchyViewerSupport.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.hasEActivity(element, validatedElements, valid); - - validatorHelper.isDebuggable(element, androidManifest, valid); - - validatorHelper.hasInternetPermission(element, androidManifest, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/HttpsClientValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/HttpsClientValidator.java deleted file mode 100644 index f1c071a467..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/HttpsClientValidator.java +++ /dev/null @@ -1,57 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.HttpsClient; -import org.androidannotations.helper.IdAnnotationHelper; -import org.androidannotations.helper.IdValidatorHelper; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.rclass.IRClass; -import org.androidannotations.rclass.IRClass.Res; - -public class HttpsClientValidator implements ElementValidator { - - private IdValidatorHelper validatorHelper; - - public HttpsClientValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - IdAnnotationHelper annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return HttpsClient.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); - - validatorHelper.annotationParameterIsOptionalValidResId(element, Res.RAW, "keyStore", valid); - validatorHelper.annotationParameterIsOptionalValidResId(element, Res.RAW, "trustStore", valid); - - validatorHelper.isNotPrivate(element, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/InstanceStateValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/InstanceStateValidator.java deleted file mode 100644 index aadd255824..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/InstanceStateValidator.java +++ /dev/null @@ -1,54 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.InstanceState; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class InstanceStateValidator implements ElementValidator { - - private ValidatorHelper validatorHelper; - - public InstanceStateValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return InstanceState.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.enclosingElementHasEActivityOrEFragment(element, validatedElements, valid); - - validatorHelper.isNotPrivate(element, valid); - - validatorHelper.canBeSavedAsInstanceState(element, 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 deleted file mode 100644 index 859d0af894..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ItemClickValidator.java +++ /dev/null @@ -1,67 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.ItemClick; -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 ItemClickValidator implements ElementValidator { - - private IdAnnotationHelper annotationHelper; - private IdValidatorHelper validatorHelper; - - public ItemClickValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return ItemClick.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.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 deleted file mode 100644 index 08d8af4b4b..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ItemLongClickValidator.java +++ /dev/null @@ -1,67 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.ItemLongClick; -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 ItemLongClickValidator implements ElementValidator { - - private IdValidatorHelper validatorHelper; - - public ItemLongClickValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - IdAnnotationHelper annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return ItemLongClick.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.returnTypeIsVoidOrBoolean(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 deleted file mode 100644 index c0e98089ea..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ItemSelectedValidator.java +++ /dev/null @@ -1,69 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.ItemSelect; -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 ItemSelectedValidator implements ElementValidator { - - private IdValidatorHelper validatorHelper; - - public ItemSelectedValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - IdAnnotationHelper annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return ItemSelect.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.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 deleted file mode 100644 index 425fa3c6eb..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/LongClickValidator.java +++ /dev/null @@ -1,67 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.LongClick; -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 LongClickValidator implements ElementValidator { - - private IdValidatorHelper validatorHelper; - - public LongClickValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - IdAnnotationHelper annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return LongClick.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.returnTypeIsVoidOrBoolean(executableElement, valid); - - validatorHelper.param.zeroOrOneViewParameter(executableElement, valid); - - return valid.isValid(); - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ModelValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ModelValidator.java deleted file mode 100644 index a414b7d5cd..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ModelValidator.java +++ /dev/null @@ -1,63 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.util.ArrayList; -import java.util.HashSet; -import java.util.List; -import java.util.Set; - -import javax.lang.model.element.Element; - -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.model.AnnotationElementsHolder; - -public class ModelValidator { - - private List validators = new ArrayList(); - - public void register(ElementValidator validator) { - validators.add(validator); - } - - public AnnotationElements validate(AnnotationElementsHolder extractedModel) { - - /* - * We currently do not validate the elements on the ancestors, assuming - * they've already been validated. This also means some checks such as - * unique ids might not be check all situations. - */ - AnnotationElementsHolder validatedElements = extractedModel.validatingHolder(); - - for (ElementValidator validator : validators) { - String annotationName = validator.getTarget(); - - Set annotatedElements = extractedModel.getRootAnnotatedElements(annotationName); - - Set validatedAnnotatedElements = new HashSet(); - - validatedElements.putRootAnnotatedElements(annotationName, validatedAnnotatedElements); - - for (Element annotatedElement : annotatedElements) { - if (validator.validate(annotatedElement, validatedElements)) { - validatedAnnotatedElements.add(annotatedElement); - } - } - } - return validatedElements; - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/NoTitleValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/NoTitleValidator.java deleted file mode 100644 index d486ded02f..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/NoTitleValidator.java +++ /dev/null @@ -1,50 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.NoTitle; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class NoTitleValidator implements ElementValidator { - - private ValidatorHelper validatorHelper; - - public NoTitleValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return NoTitle.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.hasEActivity(element, validatedElements, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/NonConfigurationInstanceValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/NonConfigurationInstanceValidator.java deleted file mode 100644 index aba678c0ce..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/NonConfigurationInstanceValidator.java +++ /dev/null @@ -1,52 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.NonConfigurationInstance; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class NonConfigurationInstanceValidator implements ElementValidator { - - private ValidatorHelper validatorHelper; - - public NonConfigurationInstanceValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return NonConfigurationInstance.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.enclosingElementHasEActivity(element, validatedElements, valid); - - validatorHelper.isNotPrivate(element, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OnActivityResultValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OnActivityResultValidator.java deleted file mode 100644 index 6849da586c..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OnActivityResultValidator.java +++ /dev/null @@ -1,101 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.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.OnActivityResult; -import org.androidannotations.helper.CanonicalNameConstants; -import org.androidannotations.helper.IdAnnotationHelper; -import org.androidannotations.helper.IdValidatorHelper; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.rclass.IRClass; - -/** - */ -public class OnActivityResultValidator implements ElementValidator { - - private final IdValidatorHelper validatorHelper; - - private final IdAnnotationHelper annotationHelper; - - public OnActivityResultValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return OnActivityResult.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.enclosingElementHasEActivityOrEFragment(element, validatedElements, valid); - - validatorHelper.isNotPrivate(element, valid); - - validatorHelper.doesntThrowException(element, valid); - - OnActivityResult onResultAnnotation = element.getAnnotation(OnActivityResult.class); - validatorHelper.annotationValuePositiveAndInAShort(element, valid, onResultAnnotation.value()); - - ExecutableElement executableElement = (ExecutableElement) element; - validatorHelper.returnTypeIsVoid(executableElement, valid); - - hasOnResultMethodParameters(executableElement, valid); - - return valid.isValid(); - } - - private void hasOnResultMethodParameters(ExecutableElement executableElement, IsValid valid) { - List parameters = executableElement.getParameters(); - boolean resultCodeParameterFound = false; - boolean intentParameterFound = false; - for (VariableElement parameter : parameters) { - TypeMirror parameterType = parameter.asType(); - if (parameterType.toString().equals(CanonicalNameConstants.INTEGER) // - || parameterType.getKind().equals(TypeKind.INT)) { - if (resultCodeParameterFound) { - annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter declaration. you can declare only one parameter of type int or java.lang.Integer"); - valid.invalidate(); - } - resultCodeParameterFound = true; - continue; - } - if (parameterType.toString().equals(CanonicalNameConstants.INTENT)) { - if (intentParameterFound) { - annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter declaration. you can declare only one parameter of type android.content.Intent"); - valid.invalidate(); - } - intentParameterFound = true; - continue; - } - valid.invalidate(); - annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter type. %s can only have a android.content.Intent parameter and/or an Integer parameter"); - } - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OptionsItemValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OptionsItemValidator.java deleted file mode 100644 index 1d8eddf1de..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OptionsItemValidator.java +++ /dev/null @@ -1,74 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.OptionsItem; -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 OptionsItemValidator implements ElementValidator { - - private IdValidatorHelper validatorHelper; - - public OptionsItemValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - IdAnnotationHelper annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass) { - @Override - public String actionName() { - return "Selected"; - }; - }; - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return OptionsItem.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.enclosingElementHasEActivityOrEFragment(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.returnTypeIsVoidOrBoolean(executableElement, valid); - - validatorHelper.param.zeroOrOneMenuItemParameter(executableElement, valid); - - return valid.isValid(); - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OptionsMenuItemValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OptionsMenuItemValidator.java deleted file mode 100644 index b5ca0d5815..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OptionsMenuItemValidator.java +++ /dev/null @@ -1,64 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.type.TypeMirror; - -import org.androidannotations.annotations.OptionsMenuItem; -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 OptionsMenuItemValidator implements ElementValidator { - - private IdValidatorHelper validatorHelper; - - public OptionsMenuItemValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - IdAnnotationHelper annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return OptionsMenuItem.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); - - TypeMirror uiFieldTypeMirror = element.asType(); - - validatorHelper.isDeclaredType(element, valid, uiFieldTypeMirror); - - validatorHelper.extendsMenuItem(element, valid); - - validatorHelper.resIdsExist(element, Res.ID, FallbackStrategy.USE_ELEMENT_NAME, valid); - - validatorHelper.isNotPrivate(element, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OptionsMenuValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OptionsMenuValidator.java deleted file mode 100644 index 819ca1aefd..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OptionsMenuValidator.java +++ /dev/null @@ -1,55 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.OptionsMenu; -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 OptionsMenuValidator implements ElementValidator { - - private IdValidatorHelper validatorHelper; - - public OptionsMenuValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - IdAnnotationHelper annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return OptionsMenu.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.hasEActivityOrEFragment(element, validatedElements, valid); - - validatorHelper.resIdsExist(element, Res.MENU, FallbackStrategy.NEED_RES_ID, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OrmLiteDaoValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OrmLiteDaoValidator.java deleted file mode 100644 index 780cd2ea24..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/OrmLiteDaoValidator.java +++ /dev/null @@ -1,60 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.OrmLiteDao; -import org.androidannotations.helper.IdAnnotationHelper; -import org.androidannotations.helper.IdValidatorHelper; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.rclass.IRClass; - -public class OrmLiteDaoValidator implements ElementValidator { - - private IdValidatorHelper validatorHelper; - private IdAnnotationHelper annotationHelper; - - public OrmLiteDaoValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return OrmLiteDao.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.hasOrmLiteJars(element, valid); - - validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); - - validatorHelper.isNotPrivate(element, valid); - - validatorHelper.extendsOrmLiteDaoWithValidModelParameter(element, valid); - - validatorHelper.hasASqlLiteOpenHelperParameterizedType(element, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/PrefValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/PrefValidator.java deleted file mode 100644 index b612feb5bd..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/PrefValidator.java +++ /dev/null @@ -1,54 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.sharedpreferences.Pref; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class PrefValidator implements ElementValidator { - - private ValidatorHelper validatorHelper; - - public PrefValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return Pref.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); - - validatorHelper.isNotPrivate(element, valid); - - validatorHelper.isSharedPreference(element, validatedElements, 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 deleted file mode 100644 index b6909b9e20..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ProduceValidator.java +++ /dev/null @@ -1,71 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 static org.androidannotations.helper.CanonicalNameConstants.PRODUCE; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; - -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class ProduceValidator implements ElementValidator { - - private final ValidatorHelper validatorHelper; - private final TargetAnnotationHelper annotationHelper; - - public ProduceValidator(ProcessingEnvironment processingEnv) { - annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return PRODUCE; - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - if (!annotationHelper.enclosingElementHasEnhancedComponentAnnotation(element)) { - return false; - } - - IsValid valid = new IsValid(); - - ExecutableElement executableElement = (ExecutableElement) element; - - /* - * We check that twice to skip invalid annotated elements - */ - validatorHelper.enclosingElementHasEnhancedComponentAnnotation(executableElement, validatedElements, valid); - - validatorHelper.returnTypeIsNotVoid(executableElement, valid); - - validatorHelper.isPublic(element, valid); - - validatorHelper.doesntThrowException(executableElement, valid); - - validatorHelper.isNotFinal(element, valid); - - validatorHelper.param.zeroParameter(executableElement, valid); - - return valid.isValid(); - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ResValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ResValidator.java deleted file mode 100644 index 14cddc0c7c..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ResValidator.java +++ /dev/null @@ -1,63 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.type.TypeMirror; - -import org.androidannotations.helper.IdAnnotationHelper; -import org.androidannotations.helper.IdValidatorHelper; -import org.androidannotations.helper.IdValidatorHelper.FallbackStrategy; -import org.androidannotations.model.AndroidRes; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.rclass.IRClass; - -public class ResValidator implements ElementValidator { - - private final AndroidRes androidValue; - private IdValidatorHelper validatorHelper; - - public ResValidator(AndroidRes androidValue, ProcessingEnvironment processingEnv, IRClass rClass) { - this.androidValue = androidValue; - IdAnnotationHelper annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return androidValue.getTarget(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); - - TypeMirror fieldTypeMirror = element.asType(); - - validatorHelper.allowedType(element, valid, fieldTypeMirror, androidValue.getAllowedTypes()); - - validatorHelper.resIdsExist(element, androidValue.getRInnerClass(), FallbackStrategy.USE_ELEMENT_NAME, valid); - - validatorHelper.isNotPrivate(element, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/RestServiceValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/RestServiceValidator.java deleted file mode 100644 index 814397ccfa..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/RestServiceValidator.java +++ /dev/null @@ -1,55 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.rest.Rest; -import org.androidannotations.annotations.rest.RestService; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class RestServiceValidator implements ElementValidator { - - private ValidatorHelper validatorHelper; - - public RestServiceValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return RestService.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); - - validatorHelper.isNotPrivate(element, valid); - - validatorHelper.typeHasAnnotation(Rest.class, element, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/RoboGuiceValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/RoboGuiceValidator.java deleted file mode 100644 index 9fc81c093f..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/RoboGuiceValidator.java +++ /dev/null @@ -1,52 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.RoboGuice; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class RoboGuiceValidator implements ElementValidator { - - private ValidatorHelper validatorHelper; - - public RoboGuiceValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return RoboGuice.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.hasEActivity(element, validatedElements, valid); - - validatorHelper.hasRoboGuiceJars(element, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/RootContextValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/RootContextValidator.java deleted file mode 100644 index 918baa2cdf..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/RootContextValidator.java +++ /dev/null @@ -1,54 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.RootContext; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class RootContextValidator implements ElementValidator { - - private ValidatorHelper validatorHelper; - - public RootContextValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return RootContext.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.enclosingElementHasEBeanAnnotation(element, validatedElements, valid); - - validatorHelper.extendsContext(element, valid); - - validatorHelper.isNotPrivate(element, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/RunnableValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/RunnableValidator.java deleted file mode 100644 index f89b7e1f45..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/RunnableValidator.java +++ /dev/null @@ -1,64 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class RunnableValidator implements ElementValidator { - - private final String annotationName; - private ValidatorHelper validatorHelper; - - public RunnableValidator(String annotationName, ProcessingEnvironment processingEnv) { - this.annotationName = annotationName; - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return annotationName; - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); - - ExecutableElement executableElement = (ExecutableElement) element; - - validatorHelper.returnTypeIsVoid(executableElement, valid); - - validatorHelper.isNotPrivate(element, valid); - - validatorHelper.doesntThrowException(executableElement, valid); - - validatorHelper.isNotFinal(element, valid); - - validatorHelper.isNotSynchronized(element, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SeekBarProgressChangeValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SeekBarProgressChangeValidator.java deleted file mode 100644 index 5eab418e78..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SeekBarProgressChangeValidator.java +++ /dev/null @@ -1,107 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.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 org.androidannotations.annotations.SeekBarProgressChange; -import org.androidannotations.helper.CanonicalNameConstants; -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 SeekBarProgressChangeValidator implements ElementValidator { - - private final IdValidatorHelper validatorHelper; - - private final IdAnnotationHelper annotationHelper; - - public SeekBarProgressChangeValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return SeekBarProgressChange.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); - - ExecutableElement executableElement = (ExecutableElement) element; - validatorHelper.returnTypeIsVoid(executableElement, valid); - - hasProgressChangeMethodParameters(executableElement, valid); - - return valid.isValid(); - } - - private void hasProgressChangeMethodParameters(ExecutableElement executableElement, IsValid valid) { - List parameters = executableElement.getParameters(); - boolean seekBarParameterFound = false; - boolean fromUserParameterFound = false; - boolean progressParameterFound = false; - for (VariableElement parameter : parameters) { - String parameterType = parameter.asType().toString(); - if (parameterType.equals(CanonicalNameConstants.SEEKBAR)) { - if (seekBarParameterFound) { - annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter declaration. You can declare only one parameter of type " + CanonicalNameConstants.SEEKBAR); - valid.invalidate(); - } - seekBarParameterFound = true; - continue; - } - if (parameter.asType().getKind() == TypeKind.INT || CanonicalNameConstants.INTEGER.equals(parameterType)) { - if (progressParameterFound) { - annotationHelper.printAnnotationError(executableElement, "You can have only one parameter of type " + CanonicalNameConstants.INTEGER); - valid.invalidate(); - } - progressParameterFound = true; - continue; - } - if (parameter.asType().getKind() == TypeKind.BOOLEAN || CanonicalNameConstants.BOOLEAN.equals(parameterType)) { - if (fromUserParameterFound) { - annotationHelper.printAnnotationError(executableElement, "You can have only one parameter of type " + CanonicalNameConstants.BOOLEAN); - valid.invalidate(); - } - fromUserParameterFound = true; - continue; - } - annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter '" + parameter.toString() + "'. %s signature should be " + executableElement.getSimpleName() + "(" + CanonicalNameConstants.SEEKBAR + " seekBar, int progress, boolean fromUser). The 'fromUser' and 'progress' parameters are optional."); - valid.invalidate(); - } - } -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SeekBarTouchStartValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SeekBarTouchStartValidator.java deleted file mode 100644 index 68cb2d1207..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SeekBarTouchStartValidator.java +++ /dev/null @@ -1,34 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.SeekBarTouchStart; -import org.androidannotations.rclass.IRClass; - -public class SeekBarTouchStartValidator extends AbstractSeekBarTouchValidator { - - public SeekBarTouchStartValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - super(processingEnv, rClass); - } - - @Override - public String getTarget() { - return SeekBarTouchStart.class.getName(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SeekBarTouchStopValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SeekBarTouchStopValidator.java deleted file mode 100644 index a1707dadba..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SeekBarTouchStopValidator.java +++ /dev/null @@ -1,34 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.SeekBarTouchStop; -import org.androidannotations.rclass.IRClass; - -public class SeekBarTouchStopValidator extends AbstractSeekBarTouchValidator { - - public SeekBarTouchStopValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - super(processingEnv, rClass); - } - - @Override - public String getTarget() { - return SeekBarTouchStop.class.getName(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SharedPrefValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SharedPrefValidator.java deleted file mode 100644 index 7ff78b4f81..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SharedPrefValidator.java +++ /dev/null @@ -1,69 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.sharedpreferences.SharedPref; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.TypeElement; -import javax.lang.model.util.Elements; -import java.util.List; - -public class SharedPrefValidator implements ElementValidator { - - private final ValidatorHelper validatorHelper; - private final Elements elements; - - public SharedPrefValidator(ProcessingEnvironment processingEnv) { - elements = processingEnv.getElementUtils(); - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return SharedPref.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - TypeElement typeElement = (TypeElement) element; - - validatorHelper.isInterface(typeElement, valid); - - List inheritedMembers = elements.getAllMembers(typeElement); - - for (Element memberElement : inheritedMembers) { - if (!memberElement.getEnclosingElement().asType().toString().equals("java.lang.Object")) { - validatorHelper.isPrefMethod(memberElement, valid); - if (valid.isValid()) { - validatorHelper.hasCorrectDefaultAnnotation((ExecutableElement) memberElement, 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 deleted file mode 100644 index bd51fb91e2..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SubscribeValidator.java +++ /dev/null @@ -1,72 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 static org.androidannotations.helper.CanonicalNameConstants.SUBSCRIBE; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; - -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class SubscribeValidator implements ElementValidator { - - private final ValidatorHelper validatorHelper; - private final TargetAnnotationHelper annotationHelper; - - public SubscribeValidator(ProcessingEnvironment processingEnv) { - annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return SUBSCRIBE; - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - if (!annotationHelper.enclosingElementHasEnhancedComponentAnnotation(element)) { - return false; - } - - IsValid valid = new IsValid(); - - ExecutableElement executableElement = (ExecutableElement) element; - - /* - * We check that twice to skip invalid annotated elements - */ - validatorHelper.enclosingElementHasEnhancedComponentAnnotation(executableElement, validatedElements, valid); - - validatorHelper.returnTypeIsVoid(executableElement, valid); - - validatorHelper.isPublic(element, valid); - - validatorHelper.doesntThrowException(executableElement, valid); - - validatorHelper.isNotFinal(element, valid); - - validatorHelper.param.hasExactlyOneParameter(executableElement, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SystemServiceValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SystemServiceValidator.java deleted file mode 100644 index 6936b42365..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/SystemServiceValidator.java +++ /dev/null @@ -1,57 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.SystemService; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AndroidSystemServices; -import org.androidannotations.model.AnnotationElements; - -public class SystemServiceValidator implements ElementValidator { - - private final AndroidSystemServices androidSystemServices; - private ValidatorHelper validatorHelper; - - public SystemServiceValidator(ProcessingEnvironment processingEnv, AndroidSystemServices androidSystemServices) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - this.androidSystemServices = androidSystemServices; - } - - @Override - public String getTarget() { - return SystemService.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); - - validatorHelper.androidService(androidSystemServices, element, valid); - - validatorHelper.isNotPrivate(element, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TextChangeValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TextChangeValidator.java deleted file mode 100644 index b70cc6c194..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TextChangeValidator.java +++ /dev/null @@ -1,108 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.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 org.androidannotations.annotations.TextChange; -import org.androidannotations.helper.CanonicalNameConstants; -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 TextChangeValidator implements ElementValidator { - - private final IdValidatorHelper validatorHelper; - - private final IdAnnotationHelper annotationHelper; - - public TextChangeValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return TextChange.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); - - ExecutableElement executableElement = (ExecutableElement) element; - validatorHelper.returnTypeIsVoid(executableElement, valid); - - haveTextChangedMethodParameters(executableElement, valid); - - return valid.isValid(); - } - - private void haveTextChangedMethodParameters(ExecutableElement executableElement, IsValid valid) { - List parameters = executableElement.getParameters(); - boolean charSequenceParameterFound = false; - boolean textViewParameterFound = false; - for (VariableElement parameter : parameters) { - String parameterType = parameter.asType().toString(); - if (parameterType.equals(CanonicalNameConstants.CHAR_SEQUENCE)) { - if (charSequenceParameterFound) { - annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter declaration. you can declare only one parameter of type java.lang.CharSequence"); - valid.invalidate(); - } - charSequenceParameterFound = true; - continue; - } - if (parameterType.equals(CanonicalNameConstants.TEXT_VIEW)) { - if (textViewParameterFound) { - annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter declaration. you can declare only one parameter of type android.widget.TextView"); - valid.invalidate(); - } - textViewParameterFound = true; - continue; - } - if (parameter.asType().getKind() == TypeKind.INT || CanonicalNameConstants.INTEGER.equals(parameterType)) { - String parameterName = parameter.toString(); - if ("start".equals(parameterName) || "before".equals(parameterName) || "count".equals(parameterName)) { - continue; - } - annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter name. You can only have start, before, or count parameter name. Try to pick a prameter from the android.text.TextWatcher.onTextChanged() method."); - valid.invalidate(); - continue; - } - annotationHelper.printAnnotationError(executableElement, "Unrecognized parameter (" + parameter.toString() + "). %s can only have a android.widget.TextView parameter and/or parameters from android.text.TextWatcher.onTextChanged() method."); - valid.invalidate(); - } - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TouchValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TouchValidator.java deleted file mode 100644 index 15d0ac29de..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TouchValidator.java +++ /dev/null @@ -1,68 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.Touch; -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 TouchValidator implements ElementValidator { - - private IdValidatorHelper validatorHelper; - - public TouchValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - IdAnnotationHelper annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return Touch.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.returnTypeIsVoidOrBoolean(executableElement, valid); - - validatorHelper.param.hasOneMotionEventOrTwoMotionEventViewParameters(executableElement, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TraceValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TraceValidator.java deleted file mode 100644 index 6b29aa7d04..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TraceValidator.java +++ /dev/null @@ -1,54 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.Trace; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class TraceValidator implements ElementValidator { - - private final ValidatorHelper validatorHelper; - - public TraceValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return Trace.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); - - validatorHelper.isNotPrivate(element, valid); - - validatorHelper.hasValidLogLevel(element, 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 deleted file mode 100644 index 769d7cd1ac..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/TransactionalValidator.java +++ /dev/null @@ -1,61 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.Transactional; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class TransactionalValidator implements ElementValidator { - - private ValidatorHelper validatorHelper; - - public TransactionalValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return Transactional.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); - - validatorHelper.isNotPrivate(element, valid); - - ExecutableElement executableElement = (ExecutableElement) element; - - validatorHelper.doesntThrowException(executableElement, valid); - - validatorHelper.isNotFinal(element, valid); - - validatorHelper.param.hasOneOrTwoParametersAndFirstIsDb(executableElement, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ViewByIdValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ViewByIdValidator.java deleted file mode 100644 index 8f637849be..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ViewByIdValidator.java +++ /dev/null @@ -1,65 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.type.TypeMirror; - -import org.androidannotations.annotations.ViewById; -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 ViewByIdValidator implements ElementValidator { - - private IdValidatorHelper validatorHelper; - private IdAnnotationHelper annotationHelper; - - public ViewByIdValidator(ProcessingEnvironment processingEnv, IRClass rClass) { - annotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - validatorHelper = new IdValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return ViewById.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); - - TypeMirror uiFieldTypeMirror = element.asType(); - - validatorHelper.isDeclaredType(element, valid, uiFieldTypeMirror); - - validatorHelper.extendsView(element, valid); - - validatorHelper.resIdsExist(element, Res.ID, FallbackStrategy.USE_ELEMENT_NAME, valid); - - validatorHelper.isNotPrivate(element, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/WindowFeatureValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/WindowFeatureValidator.java deleted file mode 100644 index 644b00236b..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/WindowFeatureValidator.java +++ /dev/null @@ -1,49 +0,0 @@ -/** - * Copyright (C) 2010-2013 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 org.androidannotations.annotations.WindowFeature; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; - -public class WindowFeatureValidator implements ElementValidator { - - private ValidatorHelper validatorHelper; - - public WindowFeatureValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return WindowFeature.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - - validatorHelper.hasEActivity(element, validatedElements, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/AcceptValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/AcceptValidator.java deleted file mode 100644 index 956b46a692..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/AcceptValidator.java +++ /dev/null @@ -1,69 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.rest; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.TypeElement; - -import org.androidannotations.annotations.rest.Accept; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.ElementValidator; -import org.androidannotations.validation.IsValid; - -public class AcceptValidator implements ElementValidator { - - private ValidatorHelper validatorHelper; - - public AcceptValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return Accept.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - // Interface annotated - if (element instanceof TypeElement) { - - validatorHelper.elementHasRestAnnotation(element, validatedElements, valid); - - // Method Annotated - } else { - ExecutableElement executableElement = (ExecutableElement) element; - - validatorHelper.enclosingElementHasRestAnnotation(executableElement, validatedElements, valid); - - validatorHelper.elementHasGetOrPostAnnotation(executableElement, validatedElements, valid); - - validatorHelper.throwsOnlyRestClientException(executableElement, valid); - - } - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/DeleteValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/DeleteValidator.java deleted file mode 100644 index 4ed643ebd0..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/DeleteValidator.java +++ /dev/null @@ -1,66 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.rest; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; - -import org.androidannotations.annotations.rest.Delete; -import org.androidannotations.helper.RestAnnotationHelper; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.ElementValidator; -import org.androidannotations.validation.IsValid; - -public class DeleteValidator implements ElementValidator { - - private ValidatorHelper validatorHelper; - private RestAnnotationHelper restAnnotationHelper; - - public DeleteValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - restAnnotationHelper = new RestAnnotationHelper(processingEnv, getTarget()); - } - - @Override - public String getTarget() { - return Delete.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.notAlreadyValidated(element, validatedElements, valid); - - validatorHelper.enclosingElementHasRestAnnotation(element, validatedElements, valid); - - ExecutableElement executableElement = (ExecutableElement) element; - - validatorHelper.throwsOnlyRestClientException(executableElement, valid); - - validatorHelper.returnTypeIsVoid(executableElement, valid); - - restAnnotationHelper.urlVariableNamesExistInParametersAndHasNoOneMoreParameter(executableElement, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/GetValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/GetValidator.java deleted file mode 100644 index 2a19b4862f..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/GetValidator.java +++ /dev/null @@ -1,66 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.rest; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; - -import org.androidannotations.annotations.rest.Get; -import org.androidannotations.helper.RestAnnotationHelper; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.ElementValidator; -import org.androidannotations.validation.IsValid; - -public class GetValidator implements ElementValidator { - - private ValidatorHelper validatorHelper; - private RestAnnotationHelper restAnnotationHelper; - - public GetValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - restAnnotationHelper = new RestAnnotationHelper(processingEnv, getTarget()); - } - - @Override - public String getTarget() { - return Get.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.notAlreadyValidated(element, validatedElements, valid); - - validatorHelper.enclosingElementHasRestAnnotation(element, validatedElements, valid); - - ExecutableElement executableElement = (ExecutableElement) element; - - validatorHelper.throwsOnlyRestClientException(executableElement, valid); - - validatorHelper.doesNotReturnPrimitive(executableElement, valid); - - restAnnotationHelper.urlVariableNamesExistInParametersAndHasNoOneMoreParameter(executableElement, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/HeadValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/HeadValidator.java deleted file mode 100644 index d5c0b7e2b9..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/HeadValidator.java +++ /dev/null @@ -1,66 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.rest; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; - -import org.androidannotations.annotations.rest.Head; -import org.androidannotations.helper.RestAnnotationHelper; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.ElementValidator; -import org.androidannotations.validation.IsValid; - -public class HeadValidator implements ElementValidator { - - private ValidatorHelper validatorHelper; - private RestAnnotationHelper restAnnotationHelper; - - public HeadValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - restAnnotationHelper = new RestAnnotationHelper(processingEnv, getTarget()); - } - - @Override - public String getTarget() { - return Head.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.notAlreadyValidated(element, validatedElements, valid); - - validatorHelper.enclosingElementHasRestAnnotation(element, validatedElements, valid); - - ExecutableElement executableElement = (ExecutableElement) element; - - validatorHelper.throwsOnlyRestClientException(executableElement, valid); - - validatorHelper.hasHttpHeadersReturnType(executableElement, valid); - - restAnnotationHelper.urlVariableNamesExistInParametersAndHasNoOneMoreParameter(executableElement, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/OptionsValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/OptionsValidator.java deleted file mode 100644 index efa8e67d07..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/OptionsValidator.java +++ /dev/null @@ -1,66 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.rest; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; - -import org.androidannotations.annotations.rest.Options; -import org.androidannotations.helper.RestAnnotationHelper; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.ElementValidator; -import org.androidannotations.validation.IsValid; - -public class OptionsValidator implements ElementValidator { - - private ValidatorHelper validatorHelper; - private RestAnnotationHelper restAnnotationHelper; - - public OptionsValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - restAnnotationHelper = new RestAnnotationHelper(processingEnv, getTarget()); - } - - @Override - public String getTarget() { - return Options.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.notAlreadyValidated(element, validatedElements, valid); - - validatorHelper.enclosingElementHasRestAnnotation(element, validatedElements, valid); - - ExecutableElement executableElement = (ExecutableElement) element; - - validatorHelper.throwsOnlyRestClientException(executableElement, valid); - - validatorHelper.hasSetOfHttpMethodReturnType(executableElement, valid); - - restAnnotationHelper.urlVariableNamesExistInParametersAndHasNoOneMoreParameter(executableElement, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/PostValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/PostValidator.java deleted file mode 100644 index f5e920518d..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/PostValidator.java +++ /dev/null @@ -1,66 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.rest; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; - -import org.androidannotations.annotations.rest.Post; -import org.androidannotations.helper.RestAnnotationHelper; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.ElementValidator; -import org.androidannotations.validation.IsValid; - -public class PostValidator implements ElementValidator { - - private ValidatorHelper validatorHelper; - private RestAnnotationHelper restAnnotationHelper; - - public PostValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - restAnnotationHelper = new RestAnnotationHelper(processingEnv, getTarget()); - } - - @Override - public String getTarget() { - return Post.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.notAlreadyValidated(element, validatedElements, valid); - - validatorHelper.enclosingElementHasRestAnnotation(element, validatedElements, valid); - - ExecutableElement executableElement = (ExecutableElement) element; - - validatorHelper.throwsOnlyRestClientException(executableElement, valid); - - validatorHelper.doesNotReturnPrimitive(executableElement, valid); - - restAnnotationHelper.urlVariableNamesExistInParametersAndHasOnlyOneMoreParameter(executableElement, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/PutValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/PutValidator.java deleted file mode 100644 index dbd2cb739a..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/PutValidator.java +++ /dev/null @@ -1,66 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.rest; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; - -import org.androidannotations.annotations.rest.Put; -import org.androidannotations.helper.RestAnnotationHelper; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.ElementValidator; -import org.androidannotations.validation.IsValid; - -public class PutValidator implements ElementValidator { - - private ValidatorHelper validatorHelper; - private RestAnnotationHelper restAnnotationHelper; - - public PutValidator(ProcessingEnvironment processingEnv) { - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - restAnnotationHelper = new RestAnnotationHelper(processingEnv, getTarget()); - } - - @Override - public String getTarget() { - return Put.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - - IsValid valid = new IsValid(); - - validatorHelper.notAlreadyValidated(element, validatedElements, valid); - - validatorHelper.enclosingElementHasRestAnnotation(element, validatedElements, valid); - - ExecutableElement executableElement = (ExecutableElement) element; - - validatorHelper.throwsOnlyRestClientException(executableElement, valid); - - validatorHelper.returnTypeIsVoid(executableElement, valid); - - restAnnotationHelper.urlVariableNamesExistInParametersAndHasOnlyOneMoreParameter(executableElement, valid); - - return valid.isValid(); - } - -} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/RestValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/RestValidator.java deleted file mode 100644 index 1b62c6ae87..0000000000 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/rest/RestValidator.java +++ /dev/null @@ -1,73 +0,0 @@ -/** - * Copyright (C) 2010-2013 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.rest; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; - -import org.androidannotations.annotations.rest.Rest; -import org.androidannotations.helper.AndroidManifest; -import org.androidannotations.helper.TargetAnnotationHelper; -import org.androidannotations.helper.ValidatorHelper; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.validation.ElementValidator; -import org.androidannotations.validation.IsValid; - -public class RestValidator implements ElementValidator { - - private final ValidatorHelper validatorHelper; - private final AndroidManifest androidManifest; - - public RestValidator(ProcessingEnvironment processingEnv, AndroidManifest androidManifest) { - this.androidManifest = androidManifest; - TargetAnnotationHelper annotationHelper = new TargetAnnotationHelper(processingEnv, getTarget()); - validatorHelper = new ValidatorHelper(annotationHelper); - } - - @Override - public String getTarget() { - return Rest.class.getName(); - } - - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - - TypeElement typeElement = (TypeElement) element; - - validatorHelper.notAlreadyValidated(element, validatedElements, valid); - - validatorHelper.hasSpringAndroidJars(element, valid); - - validatorHelper.isInterface(typeElement, valid); - - validatorHelper.isTopLevel(typeElement, valid); - - validatorHelper.doesNotExtendOtherInterfaces(typeElement, valid); - - validatorHelper.unannotatedMethodReturnsRestTemplate(typeElement, valid); - - validatorHelper.validateConverters(element, valid); - - validatorHelper.validateInterceptors(element, valid); - - validatorHelper.hasInternetPermission(typeElement, androidManifest, valid); - - return valid.isValid(); - } - -} From 3d0292f62a92b342b59a95bc51f4bbf7a8ac6fa2 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 6 Jun 2013 17:05:06 +0200 Subject: [PATCH 70/86] Make onCreate accessible for tests --- .../test15/EmptyActivityWithoutLayout.java | 6 +++++ .../test15/ThreadActivity.java | 15 ++++++++---- .../test15/TracedActivity.java | 23 ++++++++++--------- .../test15/TransactionalActivity.java | 11 ++++++--- .../test15/menu/OptionsMenuActivity.java | 6 +++++ .../test15/sherlock/MySherlockActivity.java | 6 +++++ 6 files changed, 48 insertions(+), 19 deletions(-) diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/EmptyActivityWithoutLayout.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/EmptyActivityWithoutLayout.java index 23d017c9ac..9c56b59e18 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/EmptyActivityWithoutLayout.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/EmptyActivityWithoutLayout.java @@ -17,8 +17,14 @@ import android.app.Activity; +import android.os.Bundle; import org.androidannotations.annotations.EActivity; @EActivity public class EmptyActivityWithoutLayout extends Activity { + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + } } diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ThreadActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ThreadActivity.java index 83410dd0de..52ed8aebbe 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ThreadActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ThreadActivity.java @@ -15,10 +15,8 @@ */ package org.androidannotations.test15; -import java.util.List; -import java.util.Map; -import java.util.Set; - +import android.app.Activity; +import android.os.Bundle; import org.androidannotations.annotations.Background; import org.androidannotations.annotations.EActivity; import org.androidannotations.annotations.UiThread; @@ -26,11 +24,18 @@ import org.androidannotations.test15.ebean.SomeBean; import org.androidannotations.test15.instancestate.MySerializableBean; -import android.app.Activity; +import java.util.List; +import java.util.Map; +import java.util.Set; @EActivity public class ThreadActivity extends Activity { + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + } + @UiThread void emptyUiMethod() { diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/TracedActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/TracedActivity.java index ddf51cafff..5c37dd0ef7 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/TracedActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/TracedActivity.java @@ -15,22 +15,18 @@ */ package org.androidannotations.test15; -import java.io.IOException; -import java.util.List; -import java.util.Map; -import java.util.Set; - import android.app.Activity; import android.database.sqlite.SQLiteDatabase; +import android.os.Bundle; import android.util.Log; - -import org.androidannotations.annotations.Background; -import org.androidannotations.annotations.EActivity; -import org.androidannotations.annotations.Trace; -import org.androidannotations.annotations.Transactional; -import org.androidannotations.annotations.UiThread; +import org.androidannotations.annotations.*; import org.androidannotations.test15.instancestate.MySerializableBean; +import java.io.IOException; +import java.util.List; +import java.util.Map; +import java.util.Set; + @EActivity public class TracedActivity extends Activity { @@ -44,6 +40,11 @@ public class TracedActivity extends Activity { public boolean overloadedMethodInt = false; public boolean overloadedMethodIntFLoat = false; + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + } + @Trace Object tracedMethod(List>>> param1, Void param2) throws IOException { tracedMethodCalled = true; diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/TransactionalActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/TransactionalActivity.java index 3389d19cbf..bff0f2efee 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/TransactionalActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/TransactionalActivity.java @@ -15,19 +15,24 @@ */ package org.androidannotations.test15; -import java.util.List; - import android.app.Activity; import android.database.sqlite.SQLiteDatabase; - +import android.os.Bundle; import org.androidannotations.annotations.Background; import org.androidannotations.annotations.EActivity; import org.androidannotations.annotations.Transactional; import org.androidannotations.test15.instancestate.MySerializableBean; +import java.util.List; + @EActivity public class TransactionalActivity extends Activity { + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + } + @Transactional void successfulTransaction(SQLiteDatabase db) { db.execSQL("Some SQL"); diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/menu/OptionsMenuActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/menu/OptionsMenuActivity.java index 94bb0fd767..7bced20370 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/menu/OptionsMenuActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/menu/OptionsMenuActivity.java @@ -16,6 +16,7 @@ package org.androidannotations.test15.menu; import android.app.Activity; +import android.os.Bundle; import android.view.MenuItem; import org.androidannotations.annotations.EActivity; @@ -41,6 +42,11 @@ public class OptionsMenuActivity extends Activity { boolean multipleMenuItems; boolean menu_add; + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + } + @OptionsItem void menuRefreshSelected() { menuRefreshSelected = true; diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/sherlock/MySherlockActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/sherlock/MySherlockActivity.java index 8e88ea9c3d..f8ae927243 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/sherlock/MySherlockActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/sherlock/MySherlockActivity.java @@ -17,6 +17,7 @@ +import android.os.Bundle; import com.actionbarsherlock.app.SherlockActivity; import com.actionbarsherlock.view.MenuItem; import org.androidannotations.annotations.EActivity; @@ -36,6 +37,11 @@ public class MySherlockActivity extends SherlockActivity { boolean multipleMenuItems; boolean menu_add; + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + } + @OptionsItem void menuRefreshSelected() { menuRefreshSelected = true; From ae63ccf58b1ad7215e20209c5fb01803322874fe Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 6 Jun 2013 17:05:38 +0200 Subject: [PATCH 71/86] Add getInitBody method --- .../handler/AfterInjectHandler.java | 2 +- .../org/androidannotations/handler/AppHandler.java | 2 +- .../org/androidannotations/handler/BeanHandler.java | 2 +- .../handler/CustomTitleHandler.java | 2 +- .../androidannotations/handler/ExtraHandler.java | 2 +- .../handler/FullscreenHandler.java | 2 +- .../handler/HttpsClientHandler.java | 2 +- .../androidannotations/handler/NoTitleHandler.java | 2 +- .../handler/OrmLiteDaoHandler.java | 2 +- .../org/androidannotations/handler/PrefHandler.java | 2 +- .../org/androidannotations/handler/ResHandler.java | 2 +- .../handler/RoboGuiceHandler.java | 2 +- .../handler/RootContextHanlder.java | 2 +- .../handler/SystemServiceHandler.java | 2 +- .../handler/WindowFeatureHandler.java | 2 +- .../handler/rest/RestServiceHandler.java | 2 +- .../helper/ViewNotifierHelper.java | 4 +++- .../androidannotations/holder/EActivityHolder.java | 4 ++-- .../androidannotations/holder/EComponentHolder.java | 8 ++++++-- .../holder/EComponentWithViewSupportHolder.java | 2 +- .../androidannotations/holder/EFragmentHolder.java | 4 ++-- .../org/androidannotations/holder/EViewHolder.java | 13 +++++++++++++ 22 files changed, 43 insertions(+), 24 deletions(-) diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterInjectHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterInjectHandler.java index 93595e225d..424c513a47 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterInjectHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterInjectHandler.java @@ -37,6 +37,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { @Override public void process(Element element, EComponentHolder holder) { String methodName = element.getSimpleName().toString(); - holder.getInit().body().invoke(methodName); + holder.getInitBody().invoke(methodName); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java index 1387d20f3b..25fe4aa125 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java @@ -39,6 +39,6 @@ public void process(Element element, EComponentHolder holder) { String applicationQualifiedName = element.asType().toString(); JClass applicationClass = holder.refClass(applicationQualifiedName + ModelConstants.GENERATION_SUFFIX); - holder.getInit().body().assign(ref(fieldName), applicationClass.staticInvoke(EApplicationHolder.GET_APPLICATION_INSTANCE)); + holder.getInitBody().assign(ref(fieldName), applicationClass.staticInvoke(EApplicationHolder.GET_APPLICATION_INSTANCE)); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java index cd42d4f2c5..0a7b9bd0a0 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java @@ -55,7 +55,7 @@ public void process(Element element, EComponentHolder holder) throws Exception { JClass injectedClass = holder.refClass(typeQualifiedName + GENERATION_SUFFIX); JFieldRef beanField = ref(fieldName); - JBlock block = holder.getInit().body(); + JBlock block = holder.getInitBody(); boolean hasNonConfigurationInstanceAnnotation = element.getAnnotation(NonConfigurationInstance.class) != null; if (hasNonConfigurationInstanceAnnotation) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java index 0358ec3329..a710c57106 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java @@ -40,7 +40,7 @@ public void process(Element element, EActivityHolder holder) { JFieldRef contentViewId = annotationHelper.extractAnnotationFieldRefs(holder, element, getTarget(), rClass.get(IRClass.Res.LAYOUT), false).get(0); JFieldRef customTitleFeature = holder.classes().WINDOW.staticRef("FEATURE_CUSTOM_TITLE"); - holder.getInit().body().invoke("requestWindowFeature").arg(customTitleFeature); + holder.getInitBody().invoke("requestWindowFeature").arg(customTitleFeature); onViewChangedBody.add(holder.getContextRef().invoke("getWindow").invoke("setFeatureInt").arg(customTitleFeature).arg(contentViewId)); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java index d5c0c27d70..2dd41ee53b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java @@ -83,7 +83,7 @@ private void injectExtraInComponent(Element element, HasExtras hasExtras, JField JFieldRef extraField = JExpr.ref(fieldName); JBlock ifContainsKey = injectExtrasBlock._if(JExpr.invoke(extras, "containsKey").arg(extraKeyStaticField))._then(); - JExpression restoreMethodCall = JExpr.invoke(extras, bundleHelper.getMethodNameToRestore()).arg(fieldName); + JExpression restoreMethodCall = JExpr.invoke(extras, bundleHelper.getMethodNameToRestore()).arg(extraKeyStaticField); if (bundleHelper.restoreCallNeedCastStatement()) { JClass jclass = codeModelHelper.typeMirrorToJClass(element.asType(), hasExtras); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java index de78b75eed..a6f78af978 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java @@ -27,6 +27,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { @Override public void process(Element element, EActivityHolder holder) { JFieldRef fullScreen = holder.classes().WINDOW_MANAGER_LAYOUT_PARAMS.staticRef("FLAG_FULLSCREEN"); - holder.getInit().body().invoke("getWindow").invoke("setFlags").arg(fullScreen).arg(fullScreen); + holder.getInitBody().invoke("getWindow").invoke("setFlags").arg(fullScreen).arg(fullScreen); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java index f59ff79277..f07ad01c19 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java @@ -48,7 +48,7 @@ public void process(Element element, EComponentHolder holder) throws Exception { boolean useCustomKeyStore = ResId.DEFAULT_VALUE != keyStoreRawId; String fieldName = element.getSimpleName().toString(); - JBlock methodBody = holder.getInit().body(); + JBlock methodBody = holder.getInitBody(); ProcessHolder.Classes classes = holder.classes(); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java index bd267515a2..c27e65a267 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java @@ -28,6 +28,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { public void process(Element element, EActivityHolder holder) { JFieldRef noTitle = holder.classes().WINDOW.staticRef("FEATURE_NO_TITLE"); - holder.getInit().body().invoke("requestWindowFeature").arg(noTitle); + holder.getInitBody().invoke("requestWindowFeature").arg(noTitle); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java index 100d780512..f8a3f4de39 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java @@ -49,7 +49,7 @@ public void process(Element element, EComponentHolder holder) { TypeMirror databaseHelperTypeMirror = annotationHelper.extractAnnotationParameter(element, "helper"); JFieldVar databaseHelperRef = holder.getDatabaseHelperRef(databaseHelperTypeMirror); - JBlock initBody = holder.getInit().body(); + JBlock initBody = holder.getInitBody(); JTryBlock tryBlock = initBody._try(); tryBlock.body().assign(ref(fieldName), databaseHelperRef.invoke("getDao").arg(modelClass)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java index e3a8a0de17..733a115318 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java @@ -65,7 +65,7 @@ public void process(Element element, EComponentHolder holder) { } - JBlock methodBody = holder.getInit().body(); + JBlock methodBody = holder.getInitBody(); JFieldRef field = JExpr.ref(fieldName); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java index 9f1459e779..b8de97fac1 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java @@ -65,7 +65,7 @@ public void process(Element element, EComponentHolder holder) { JFieldRef idRef = annotationHelper.extractOneAnnotationFieldRef(holder, element, resInnerClass, true); - JBlock methodBody = holder.getInit().body(); + JBlock methodBody = holder.getInitBody(); TypeMirror fieldTypeMirror = element.asType(); String fieldType = fieldTypeMirror.toString(); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java index 9be973ceb1..d5a6cd5aa0 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java @@ -108,7 +108,7 @@ private List extractListenerClasses(Element activityElement) { private void beforeCreateMethod(EActivityHolder holder, JFieldVar scope, JFieldVar eventManager, JMethod getInjector) { ProcessHolder.Classes classes = holder.classes(); - JBlock body = holder.getInit().body(); + JBlock body = holder.getInitBody(); JVar injector = body.decl(classes.INJECTOR, "injector_", invoke(getInjector)); body.assign(scope, invoke(injector, "getInstance").arg(classes.CONTEXT_SCOPE.dotclass())); body.invoke(scope, "enter").arg(_this()); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java index ea434b1559..de77a9010c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java @@ -42,7 +42,7 @@ public void process(Element element, EBeanHolder holder) { TypeMirror elementType = element.asType(); String typeQualifiedName = elementType.toString(); - JBlock body = holder.getInit().body(); + JBlock body = holder.getInitBody(); JExpression contextRef = holder.getContextRef(); if (CanonicalNameConstants.CONTEXT.equals(typeQualifiedName)) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java index d1d8183019..3fd08298b5 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java @@ -42,7 +42,7 @@ public void process(Element element, EComponentHolder holder) { JFieldRef serviceRef = androidSystemServices.getServiceConstant(serviceType, holder); - JBlock methodBody = holder.getInit().body(); + JBlock methodBody = holder.getInitBody(); methodBody.assign(ref(fieldName), cast(holder.refClass(fieldTypeQualifiedName), holder.getContextRef().invoke("getSystemService").arg(serviceRef))); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/WindowFeatureHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/WindowFeatureHandler.java index 92528d326b..60eaf181e1 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/WindowFeatureHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/WindowFeatureHandler.java @@ -30,7 +30,7 @@ public void process(Element element, EActivityHolder holder) throws Exception { int[] features = annotation.value(); for (int feature : features) { - holder.getInit().body().invoke("requestWindowFeature").arg(JExpr.lit(feature)); + holder.getInitBody().invoke("requestWindowFeature").arg(JExpr.lit(feature)); } } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestServiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestServiceHandler.java index 95ae95d865..2b75434dbf 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestServiceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestServiceHandler.java @@ -43,7 +43,7 @@ public void process(Element element, EComponentHolder holder) { String generatedClassName = interfaceName + ModelConstants.GENERATION_SUFFIX; - JBlock methodBody = holder.getInit().body(); + JBlock methodBody = holder.getInitBody(); JFieldRef field = JExpr.ref(fieldName); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ViewNotifierHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ViewNotifierHelper.java index 8535c5c1e4..94dfc750fb 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ViewNotifierHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ViewNotifierHelper.java @@ -7,6 +7,7 @@ import org.androidannotations.api.view.HasViews; import org.androidannotations.api.view.OnViewChangedNotifier; import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.holder.EViewHolder; import static com.sun.codemodel.JExpr.*; import static com.sun.codemodel.JMod.FINAL; @@ -47,7 +48,8 @@ public void resetPreviousNotifier(JBlock block, JVar previousNotifier) { public void wrapInitWithNotifier() { JBlock initBlock = holder.getInit().body(); JVar previousNotifier = replacePreviousNotifier(initBlock); - resetPreviousNotifier(initBlock, previousNotifier); + ((EViewHolder) holder).setInitBody(holder.getInit().body().block()); + resetPreviousNotifier(initBlock.block(), previousNotifier); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java index c200e343e9..aec5aa6feb 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java @@ -450,7 +450,7 @@ private void setInjectExtras() { injectExtrasBlock = injectExtrasBody._if(injectExtras.ne(_null()))._then(); getSetIntent().body().invoke(injectExtrasMethod); - getInit().body().invoke(injectExtrasMethod); + getInitBody().invoke(injectExtrasMethod); } @Override @@ -547,7 +547,7 @@ public JVar getInitNonConfigurationInstance() throws JClassAlreadyExistsExceptio } private void setInitNonConfigurationInstance() throws JClassAlreadyExistsException { - JBlock initBody = getInit().body(); + JBlock initBody = getInitBody(); JDefinedClass ncHolderClass = getNonConfigurationHolder().getGeneratedClass(); initNonConfigurationInstance = initBody.decl(ncHolderClass, "nonConfigurationInstance", cast(ncHolderClass, _super().invoke(getGetLastNonConfigurationInstance()))); initIfNonConfigurationNotNullBlock = initBody._if(initNonConfigurationInstance.ne(_null()))._then(); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java index 82d468f27f..0820bac1fa 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java @@ -42,6 +42,10 @@ public JMethod getInit() { protected abstract void setInit(); + public JBlock getInitBody() { + return getInit().body(); + } + public JVar getResourcesRef() { if (resourcesRef == null) { setResourcesRef(); @@ -50,7 +54,7 @@ public JVar getResourcesRef() { } private void setResourcesRef() { - resourcesRef = getInit().body().decl(classes().RESOURCES, "resources_", getContextRef().invoke("getResources")); + resourcesRef = getInitBody().decl(classes().RESOURCES, "resources_", getContextRef().invoke("getResources")); } public JFieldVar getDatabaseHelperRef(TypeMirror databaseHelperTypeMirror) { @@ -68,7 +72,7 @@ private JFieldVar setDatabaseHelperRef(TypeMirror databaseHelperTypeMirror) { databaseHelperRefs.put(databaseHelperTypeMirror, databaseHelperRef); JExpression dbHelperClass = databaseHelperClass.dotclass(); - getInit().body().assign(databaseHelperRef, // + getInitBody().assign(databaseHelperRef, // classes().OPEN_HELPER_MANAGER.staticInvoke("getHelper").arg(getContextRef()).arg(dbHelperClass)); return databaseHelperRef; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentWithViewSupportHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentWithViewSupportHolder.java index 66fac8ee69..e34499ca9e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentWithViewSupportHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentWithViewSupportHolder.java @@ -55,7 +55,7 @@ protected void setOnViewChanged() { onViewChangedBody = onViewChanged.body(); onViewChangedHasViewsParam = onViewChanged.param(HasViews.class, "hasViews"); JClass notifierClass = refClass(OnViewChangedNotifier.class); - getInit().body().staticInvoke(notifierClass, "registerOnViewChangedListener").arg(_this()); + getInitBody().staticInvoke(notifierClass, "registerOnViewChangedListener").arg(_this()); } public JInvocation findViewById(JFieldRef idRef) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java index ac413f2994..3797f5af84 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java @@ -121,7 +121,7 @@ private void setOnCreateOptionsMenu() { onCreateOptionsMenuMethodBody = methodBody.block(); methodBody.invoke(_super(), method).arg(onCreateOptionsMenuMenuParam).arg(onCreateOptionsMenuMenuInflaterVar); - getInit().body().invoke("setHasOptionsMenu").arg(JExpr.TRUE); + getInitBody().invoke("setHasOptionsMenu").arg(JExpr.TRUE); } private void setOnOptionsItemSelected() { @@ -249,7 +249,7 @@ private void setInjectArgs() { injectBundleArgs = injectExtrasBody.decl(classes().BUNDLE, "args_", invoke("getArguments")); injectArgsBlock = injectExtrasBody._if(injectBundleArgs.ne(_null()))._then(); - getInit().body().invoke(injectArgsMethod); + getInitBody().invoke(injectArgsMethod); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java index 88fdc5fc55..7756e3130b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java @@ -28,6 +28,7 @@ public class EViewHolder extends EComponentWithViewSupportHolder { + "are in a View." // ; + protected JBlock initBody; protected JMethod onFinishInflate; protected JFieldVar alreadyInflated; @@ -100,6 +101,18 @@ protected void setInit() { viewNotifierHelper.wrapInitWithNotifier(); } + @Override + public JBlock getInitBody() { + if (initBody == null) { + setInit(); + } + return initBody; + } + + public void setInitBody(JBlock initBody) { + this.initBody = initBody; + } + public JMethod getOnFinishInflate() { if (onFinishInflate == null) { setOnFinishInflate(); From 91914ddabb9c68dc068425f76685cc3a8bc878f3 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 6 Jun 2013 17:16:30 +0200 Subject: [PATCH 72/86] Remove useless test about no rebinding singleton --- .../test15/ebean/SomeSingletonTest.java | 25 +++++-------------- 1 file changed, 6 insertions(+), 19 deletions(-) diff --git a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ebean/SomeSingletonTest.java b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ebean/SomeSingletonTest.java index c43f86486c..0f353a892f 100644 --- a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ebean/SomeSingletonTest.java +++ b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ebean/SomeSingletonTest.java @@ -15,11 +15,8 @@ */ package org.androidannotations.test15.ebean; -import static org.fest.assertions.Assertions.assertThat; -import static org.mockito.Mockito.mock; - -import java.lang.reflect.Field; - +import android.content.Context; +import android.view.View; import org.androidannotations.api.view.HasViews; import org.androidannotations.api.view.OnViewChangedNotifier; import org.androidannotations.test15.AndroidAnnotationsTestRunner; @@ -28,8 +25,10 @@ import org.junit.Test; import org.junit.runner.RunWith; -import android.content.Context; -import android.view.View; +import java.lang.reflect.Field; + +import static org.fest.assertions.Assertions.assertThat; +import static org.mockito.Mockito.mock; @RunWith(AndroidAnnotationsTestRunner.class) public class SomeSingletonTest { @@ -47,18 +46,6 @@ public void getInstance_returns_same_instance() { assertThat(firstInstance).isSameAs(secondInstance); } - @Test - public void rebind_does_not_rebind() { - EmptyActivityWithoutLayout_ context = new EmptyActivityWithoutLayout_(); - SomeSingleton_ singleton = SomeSingleton_.getInstance_(context); - - Context initialContext = singleton.context; - - EmptyActivityWithoutLayout_ context2 = new EmptyActivityWithoutLayout_(); - singleton.rebind(context2); - assertThat(singleton.context).isSameAs(initialContext); - } - @Test public void views_are_not_injected() throws Exception { Context context = mock(Context.class); From bced1c81ec0e75a648ae5093d16a009e144d100a Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 6 Jun 2013 21:44:13 +0200 Subject: [PATCH 73/86] Handle bug with byte[] in extras --- .../androidannotations/handler/ExtraHandler.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java index 2dd41ee53b..536694402d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java @@ -97,9 +97,23 @@ private void injectExtraInComponent(Element element, HasExtras hasExtras, JField } } + + /* + * Handle the android bug : + * getIntent().getExtras().getByteArray() always returns null; + */ + restoreMethodCall = handleByteArrayExtraBug(element, extraKeyStaticField, restoreMethodCall); + ifContainsKey.assign(extraField, restoreMethodCall); } + private JExpression handleByteArrayExtraBug(Element element, JFieldVar extraKeyStaticField, JExpression restoreMethodCall) { + if ("byte[]".equals(element.asType().toString())) { + restoreMethodCall = invoke("getIntent").invoke("getByteArrayExtra").arg(extraKeyStaticField); + } + return restoreMethodCall; + } + private void createIntentInjectionMethod(Element element, HasIntentBuilder holder, JFieldVar extraKeyStaticField, String fieldName) { JDefinedClass intentBuilderClass = holder.getIntentBuilderClass(); JMethod method = intentBuilderClass.method(PUBLIC, intentBuilderClass, fieldName); From 22fd1b646295dba70105fbfff03ad6ab8d1a4e67 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 6 Jun 2013 21:56:55 +0200 Subject: [PATCH 74/86] Add license --- .../handler/AbstractListenerHandler.java | 15 +++++++++++++++ .../handler/AbstractRunnableHandler.java | 15 +++++++++++++++ .../handler/AbstractSeekBarTouchHandler.java | 15 +++++++++++++++ .../handler/AfterInjectHandler.java | 15 +++++++++++++++ .../handler/AfterTextChangeHandler.java | 15 +++++++++++++++ .../handler/AfterViewsHandler.java | 15 +++++++++++++++ .../handler/AnnotationHandler.java | 15 +++++++++++++++ .../handler/AnnotationHandlers.java | 15 +++++++++++++++ .../androidannotations/handler/AppHandler.java | 15 +++++++++++++++ .../handler/BackgroundHandler.java | 15 +++++++++++++++ .../handler/BaseAnnotationHandler.java | 15 +++++++++++++++ .../androidannotations/handler/BeanHandler.java | 15 +++++++++++++++ .../handler/BeforeTextChangeHandler.java | 15 +++++++++++++++ .../handler/CheckedChangeHandler.java | 15 +++++++++++++++ .../handler/ClickHandler.java | 15 +++++++++++++++ .../handler/CustomTitleHandler.java | 15 +++++++++++++++ .../handler/EActivityHandler.java | 15 +++++++++++++++ .../handler/EApplicationHandler.java | 15 +++++++++++++++ .../handler/EBeanHandler.java | 15 +++++++++++++++ .../handler/EFragmentHandler.java | 15 +++++++++++++++ .../handler/EProviderHandler.java | 15 +++++++++++++++ .../handler/EReceiverHandler.java | 15 +++++++++++++++ .../handler/EServiceHandler.java | 15 +++++++++++++++ .../handler/EViewGroupHandler.java | 15 +++++++++++++++ .../handler/EViewHandler.java | 15 +++++++++++++++ .../handler/ExtraHandler.java | 15 +++++++++++++++ .../handler/FocusChangeHandler.java | 15 +++++++++++++++ .../handler/FragmentArgHandler.java | 15 +++++++++++++++ .../handler/FragmentByIdHandler.java | 15 +++++++++++++++ .../handler/FragmentByTagHandler.java | 15 +++++++++++++++ .../handler/FromHtmlHandler.java | 15 +++++++++++++++ .../handler/FullscreenHandler.java | 15 +++++++++++++++ .../handler/GeneratingAnnotationHandler.java | 15 +++++++++++++++ .../handler/HierarchyViewerSupportHandler.java | 15 +++++++++++++++ .../handler/HttpsClientHandler.java | 15 +++++++++++++++ .../handler/InstanceStateHandler.java | 15 +++++++++++++++ .../handler/ItemClickHandler.java | 15 +++++++++++++++ .../handler/ItemLongClickHandler.java | 15 +++++++++++++++ .../handler/ItemSelectHandler.java | 15 +++++++++++++++ .../handler/LongClickHandler.java | 15 +++++++++++++++ .../handler/NoTitleHandler.java | 15 +++++++++++++++ .../NonConfigurationInstanceHandler.java | 15 +++++++++++++++ .../handler/OnActivityResultHandler.java | 15 +++++++++++++++ .../handler/OptionsItemHandler.java | 15 +++++++++++++++ .../handler/OptionsMenuHandler.java | 15 +++++++++++++++ .../handler/OptionsMenuItemHandler.java | 15 +++++++++++++++ .../handler/OrmLiteDaoHandler.java | 15 +++++++++++++++ .../androidannotations/handler/PrefHandler.java | 15 +++++++++++++++ .../handler/ProduceHandler.java | 15 +++++++++++++++ .../androidannotations/handler/ResHandler.java | 15 +++++++++++++++ .../handler/RoboGuiceHandler.java | 15 +++++++++++++++ .../handler/RootContextHanlder.java | 15 +++++++++++++++ .../handler/SeekBarProgressChangeHandler.java | 15 +++++++++++++++ .../handler/SeekBarTouchStartHandler.java | 15 +++++++++++++++ .../handler/SeekBarTouchStopHandler.java | 15 +++++++++++++++ .../handler/SharedPrefHandler.java | 15 +++++++++++++++ .../handler/SubscribeHandler.java | 15 +++++++++++++++ .../handler/SystemServiceHandler.java | 15 +++++++++++++++ .../handler/TextChangeHandler.java | 15 +++++++++++++++ .../handler/TouchHandler.java | 15 +++++++++++++++ .../handler/TraceHandler.java | 15 +++++++++++++++ .../handler/TransactionalHandler.java | 15 +++++++++++++++ .../handler/UiThreadHandler.java | 15 +++++++++++++++ .../handler/ViewByIdHandler.java | 15 +++++++++++++++ .../handler/WindowFeatureHandler.java | 15 +++++++++++++++ .../handler/rest/DeleteHandler.java | 15 +++++++++++++++ .../handler/rest/GetHandler.java | 15 +++++++++++++++ .../handler/rest/HeadHandler.java | 15 +++++++++++++++ .../handler/rest/OptionsHandler.java | 15 +++++++++++++++ .../handler/rest/PostHandler.java | 15 +++++++++++++++ .../handler/rest/PutHandler.java | 15 +++++++++++++++ .../handler/rest/RestHandler.java | 15 +++++++++++++++ .../handler/rest/RestMethodHandler.java | 15 +++++++++++++++ .../handler/rest/RestServiceHandler.java | 15 +++++++++++++++ .../helper/ActivityIntentBuilder.java | 15 +++++++++++++++ .../helper/GreenDroidHelper.java | 15 +++++++++++++++ .../helper/HoloEverywhereHelper.java | 15 +++++++++++++++ .../helper/IntentBuilder.java | 15 +++++++++++++++ .../helper/ServiceIntentBuilder.java | 15 +++++++++++++++ .../helper/ViewNotifierHelper.java | 15 +++++++++++++++ .../holder/BaseGeneratedClassHolder.java | 15 +++++++++++++++ .../holder/EActivityHolder.java | 15 +++++++++++++++ .../holder/EApplicationHolder.java | 15 +++++++++++++++ .../androidannotations/holder/EBeanHolder.java | 15 +++++++++++++++ .../holder/EComponentHolder.java | 15 +++++++++++++++ .../holder/EComponentWithViewSupportHolder.java | 15 +++++++++++++++ .../holder/EFragmentHolder.java | 15 +++++++++++++++ .../holder/EProviderHolder.java | 15 +++++++++++++++ .../holder/EReceiverHolder.java | 15 +++++++++++++++ .../holder/EServiceHolder.java | 15 +++++++++++++++ .../holder/EViewGroupHolder.java | 15 +++++++++++++++ .../androidannotations/holder/EViewHolder.java | 15 +++++++++++++++ .../holder/GeneratedClassHolder.java | 15 +++++++++++++++ .../androidannotations/holder/HasExtras.java | 15 +++++++++++++++ .../holder/HasInstanceState.java | 15 +++++++++++++++ .../holder/HasIntentBuilder.java | 15 +++++++++++++++ .../holder/HasOnActivityResult.java | 15 +++++++++++++++ .../holder/HasOptionsMenu.java | 15 +++++++++++++++ .../holder/InstanceStateHolder.java | 15 +++++++++++++++ .../holder/NonConfigurationHolder.java | 15 +++++++++++++++ .../holder/OnActivityResultHolder.java | 15 +++++++++++++++ .../holder/OnSeekBarChangeListenerHolder.java | 15 +++++++++++++++ .../androidannotations/holder/RestHolder.java | 15 +++++++++++++++ .../holder/RoboGuiceHolder.java | 15 +++++++++++++++ .../holder/SharedPrefHolder.java | 15 +++++++++++++++ .../holder/TextWatcherHolder.java | 15 +++++++++++++++ .../menu/ActivityWithSherlockMenu.java | 15 +++++++++++++++ .../menu/SherlockActivityWithAndroidMenu.java | 15 +++++++++++++++ .../androidannotations/menu/AndroidManifest.xml | 2 ++ .../functional-test-1-5/res/values/values.xml | 17 +++++++++++++++++ .../test15/ParcelableSerializableData.java | 15 +++++++++++++++ 111 files changed, 1654 insertions(+) diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java index c6a7dff5ae..b791b82f91 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractRunnableHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractRunnableHandler.java index 6b7b57828d..25a19875d1 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractRunnableHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractRunnableHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import org.androidannotations.holder.EComponentHolder; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractSeekBarTouchHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractSeekBarTouchHandler.java index 183a92ac3a..00ce8bb68a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractSeekBarTouchHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractSeekBarTouchHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterInjectHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterInjectHandler.java index 424c513a47..a6ebf7e9ff 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterInjectHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterInjectHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import org.androidannotations.annotations.AfterInject; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterTextChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterTextChangeHandler.java index e5a3f8175b..6667a76d55 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterTextChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterTextChangeHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterViewsHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterViewsHandler.java index 617ea6279a..82fa933083 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterViewsHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterViewsHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import org.androidannotations.annotations.AfterViews; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandler.java index dc76282783..f1e56bd753 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import org.androidannotations.helper.AndroidManifest; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 4289bac905..bb3dc7f58b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import org.androidannotations.handler.rest.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java index 25fe4aa125..b9d85b2aac 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JClass; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BackgroundHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BackgroundHandler.java index a70b970117..e35bc9c9f2 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BackgroundHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BackgroundHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JClass; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BaseAnnotationHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BaseAnnotationHandler.java index f14b1abcc1..34c65caf81 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BaseAnnotationHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BaseAnnotationHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import org.androidannotations.helper.AndroidManifest; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java index 0a7b9bd0a0..c5edb66861 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeforeTextChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeforeTextChangeHandler.java index 0a2dc2a245..236082de62 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeforeTextChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeforeTextChangeHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CheckedChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CheckedChangeHandler.java index 26484fd70b..b3fdb860ed 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CheckedChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CheckedChangeHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ClickHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ClickHandler.java index a1442eb7b5..52fc892f4b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ClickHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ClickHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java index a710c57106..ec9daaf49d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EActivityHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EActivityHandler.java index 5f11b3dc78..14f9553245 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EActivityHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EActivityHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EApplicationHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EApplicationHandler.java index ac9ae69bbb..d7e49181d1 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EApplicationHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EApplicationHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import org.androidannotations.annotations.EApplication; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EBeanHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EBeanHandler.java index d486d60fb1..b3772c1d79 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EBeanHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EBeanHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import org.androidannotations.annotations.EBean; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EFragmentHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EFragmentHandler.java index 8a8d5ab320..08e7a67d68 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EFragmentHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EFragmentHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EProviderHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EProviderHandler.java index d0355a49f9..997a4795ff 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EProviderHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EProviderHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import org.androidannotations.annotations.EProvider; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EReceiverHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EReceiverHandler.java index 6460918d02..8e73b15d8c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EReceiverHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EReceiverHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import org.androidannotations.annotations.EReceiver; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EServiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EServiceHandler.java index ced6959514..7a1dde3950 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EServiceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EServiceHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import org.androidannotations.annotations.EService; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewGroupHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewGroupHandler.java index 6db4920320..1c4d5c4163 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewGroupHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewGroupHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JExpr; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewHandler.java index 73a9658f11..8384acdfda 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import org.androidannotations.annotations.EView; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java index 536694402d..1a9c1e93a3 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FocusChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FocusChangeHandler.java index e446fbcf3b..72b03d9c0b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FocusChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FocusChangeHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentArgHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentArgHandler.java index 78a21c24b2..fec73651f1 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentArgHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentArgHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java index 662832df2e..5fb6a4a23a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java index a2d01b5fc2..381a49b67c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java index 736e023d28..e75a0386cb 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java index a6f78af978..220b09485b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JFieldRef; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/GeneratingAnnotationHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/GeneratingAnnotationHandler.java index 6de3115096..ca48b52db8 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/GeneratingAnnotationHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/GeneratingAnnotationHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import org.androidannotations.holder.GeneratedClassHolder; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HierarchyViewerSupportHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HierarchyViewerSupportHandler.java index ada1b88680..d40b6344ba 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HierarchyViewerSupportHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HierarchyViewerSupportHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JInvocation; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java index f07ad01c19..370ee12f45 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/InstanceStateHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/InstanceStateHandler.java index 3487f398c6..2dc21c8259 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/InstanceStateHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/InstanceStateHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemClickHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemClickHandler.java index a1ca6b372a..484aba76d0 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemClickHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemClickHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemLongClickHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemLongClickHandler.java index 0f93dd3b42..18538b5160 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemLongClickHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemLongClickHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemSelectHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemSelectHandler.java index 939cb51cfb..e01db5ea9b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemSelectHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemSelectHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/LongClickHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/LongClickHandler.java index a19e3cec84..e397cef142 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/LongClickHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/LongClickHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java index c27e65a267..10886e2d83 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JFieldRef; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NonConfigurationInstanceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NonConfigurationInstanceHandler.java index 388755abd6..3bb5e1f5a8 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NonConfigurationInstanceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NonConfigurationInstanceHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OnActivityResultHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OnActivityResultHandler.java index 0481cc3af9..c78ac9e67d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OnActivityResultHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OnActivityResultHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsItemHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsItemHandler.java index f4b9cfe17e..5bc7e5a56c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsItemHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsItemHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuHandler.java index 804be3ba65..c0521073fa 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuItemHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuItemHandler.java index 5f01d88fae..1acaf62f75 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuItemHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuItemHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java index f8a3f4de39..df093a9c27 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java index 733a115318..5223d84f56 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ProduceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ProduceHandler.java index 3f12232878..33276a3d2d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ProduceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ProduceHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JMethod; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java index b8de97fac1..d8346f165d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java index d5a6cd5aa0..0ded2171c2 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java index de77a9010c..038c5cafb5 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarProgressChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarProgressChangeHandler.java index 7777c0b66f..812e5958f4 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarProgressChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarProgressChangeHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarTouchStartHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarTouchStartHandler.java index c9d9113730..a2a04bce43 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarTouchStartHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarTouchStartHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarTouchStopHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarTouchStopHandler.java index 3cd4cbc754..444018ce2d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarTouchStopHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarTouchStopHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SharedPrefHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SharedPrefHandler.java index 74573320b8..f8754955d9 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SharedPrefHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SharedPrefHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SubscribeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SubscribeHandler.java index c54a3a37be..75a2a3ebc4 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SubscribeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SubscribeHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JMethod; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java index 3fd08298b5..1708ff9030 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TextChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TextChangeHandler.java index 2fa3888ccd..04db41eaf4 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TextChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TextChangeHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TouchHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TouchHandler.java index 654b477a8f..ee952ab8ed 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TouchHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TouchHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TraceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TraceHandler.java index 96860ab6e1..eaad3f5a7f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TraceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TraceHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TransactionalHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TransactionalHandler.java index 895bd64f6b..6ac4df6d03 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TransactionalHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TransactionalHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/UiThreadHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/UiThreadHandler.java index a27a085e21..c7a0d04b9e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/UiThreadHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/UiThreadHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java index b5ae7644de..f31bef595a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/WindowFeatureHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/WindowFeatureHandler.java index 60eaf181e1..1c88e42cb5 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/WindowFeatureHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/WindowFeatureHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler; import com.sun.codemodel.JExpr; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/DeleteHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/DeleteHandler.java index 0ae197a725..84ac206b70 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/DeleteHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/DeleteHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler.rest; import org.androidannotations.annotations.rest.Delete; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/GetHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/GetHandler.java index 5301f8fcaf..ad7d0d1431 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/GetHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/GetHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler.rest; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/HeadHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/HeadHandler.java index 20352b2f97..3a7a7ef419 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/HeadHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/HeadHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler.rest; import com.sun.codemodel.JClass; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/OptionsHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/OptionsHandler.java index 9f5308995e..e2928efa8d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/OptionsHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/OptionsHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler.rest; import com.sun.codemodel.JClass; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PostHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PostHandler.java index 4b9b4e99c7..0d2360ef5f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PostHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PostHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler.rest; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PutHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PutHandler.java index 220bb70838..8015cd2f4a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PutHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PutHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler.rest; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestHandler.java index 3447c6466b..c397b19418 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler.rest; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java index ff30583936..88677033a7 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler.rest; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestServiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestServiceHandler.java index 2b75434dbf..43696febab 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestServiceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestServiceHandler.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.handler.rest; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ActivityIntentBuilder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ActivityIntentBuilder.java index 36ed5c57c3..bc37efb866 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ActivityIntentBuilder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ActivityIntentBuilder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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 com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/GreenDroidHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/GreenDroidHelper.java index a42747bae2..a61867f304 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/GreenDroidHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/GreenDroidHelper.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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 javax.annotation.processing.ProcessingEnvironment; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/HoloEverywhereHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/HoloEverywhereHelper.java index 1ed2c501cb..3552a36dec 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/HoloEverywhereHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/HoloEverywhereHelper.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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 org.androidannotations.holder.EComponentHolder; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IntentBuilder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IntentBuilder.java index 93dba017ec..ea0372f0a2 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IntentBuilder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IntentBuilder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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 com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ServiceIntentBuilder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ServiceIntentBuilder.java index da3ccf5f2a..70b7e0cc4f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ServiceIntentBuilder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ServiceIntentBuilder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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 com.sun.codemodel.JClassAlreadyExistsException; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ViewNotifierHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ViewNotifierHelper.java index 94dfc750fb..ce2067cb86 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ViewNotifierHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ViewNotifierHelper.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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 com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/BaseGeneratedClassHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/BaseGeneratedClassHolder.java index 6213d60f21..76792dfd4d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/BaseGeneratedClassHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/BaseGeneratedClassHolder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java index aec5aa6feb..69a02dcc4a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EApplicationHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EApplicationHolder.java index 5cc57ae9d1..1912fa2013 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EApplicationHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EApplicationHolder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java index 2cf523d8e5..e611f07f2d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java index 0820bac1fa..829c8f0938 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentWithViewSupportHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentWithViewSupportHolder.java index e34499ca9e..b440bd02e3 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentWithViewSupportHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentWithViewSupportHolder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java index 3797f5af84..3ae3787b8e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EProviderHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EProviderHolder.java index 6fbf626bd3..9111394186 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EProviderHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EProviderHolder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EReceiverHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EReceiverHolder.java index 262b768428..38cb59065f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EReceiverHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EReceiverHolder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EServiceHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EServiceHolder.java index ae1d1a1efc..26e22867e6 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EServiceHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EServiceHolder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewGroupHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewGroupHolder.java index 2a85322fc8..4dc0562333 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewGroupHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewGroupHolder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java index 7756e3130b..a44dc0047b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/GeneratedClassHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/GeneratedClassHolder.java index 9b1b85bbc7..746a5fdac7 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/GeneratedClassHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/GeneratedClassHolder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.JClass; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasExtras.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasExtras.java index 8aca3b57d8..7685002977 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasExtras.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasExtras.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasInstanceState.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasInstanceState.java index 7d6cb988b3..94104c43e2 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasInstanceState.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasInstanceState.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasIntentBuilder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasIntentBuilder.java index 603cd5ebd8..1cb2f4fb10 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasIntentBuilder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasIntentBuilder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.JDefinedClass; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOnActivityResult.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOnActivityResult.java index 7f75d26baf..e16306d764 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOnActivityResult.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOnActivityResult.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOptionsMenu.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOptionsMenu.java index a9e287a724..0f442b9afd 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOptionsMenu.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOptionsMenu.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/InstanceStateHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/InstanceStateHolder.java index 09e555d91d..9bdbbf8271 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/InstanceStateHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/InstanceStateHolder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/NonConfigurationHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/NonConfigurationHolder.java index b5005ae37f..967d0b36e2 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/NonConfigurationHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/NonConfigurationHolder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/OnActivityResultHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/OnActivityResultHolder.java index d52f7cb822..ca2da37895 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/OnActivityResultHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/OnActivityResultHolder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/OnSeekBarChangeListenerHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/OnSeekBarChangeListenerHolder.java index b7a94e44d2..79577c4230 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/OnSeekBarChangeListenerHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/OnSeekBarChangeListenerHolder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RestHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RestHolder.java index 6127df7db7..eea756b69b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RestHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RestHolder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java index 05339be771..8a34ef2b57 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.JBlock; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/SharedPrefHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/SharedPrefHolder.java index de645a44b6..a90fb9ee04 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/SharedPrefHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/SharedPrefHolder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/TextWatcherHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/TextWatcherHolder.java index 6dda6b0506..55bf09a5c5 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/TextWatcherHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/TextWatcherHolder.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.holder; import com.sun.codemodel.*; diff --git a/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/menu/ActivityWithSherlockMenu.java b/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/menu/ActivityWithSherlockMenu.java index 955dea5d5e..da1d375dc9 100644 --- a/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/menu/ActivityWithSherlockMenu.java +++ b/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/menu/ActivityWithSherlockMenu.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.menu; import org.androidannotations.annotations.EActivity; diff --git a/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/menu/SherlockActivityWithAndroidMenu.java b/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/menu/SherlockActivityWithAndroidMenu.java index 9a7d260df3..ce03005357 100644 --- a/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/menu/SherlockActivityWithAndroidMenu.java +++ b/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/menu/SherlockActivityWithAndroidMenu.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.menu; import org.androidannotations.annotations.EActivity; diff --git a/AndroidAnnotations/androidannotations/src/test/resources/org/androidannotations/menu/AndroidManifest.xml b/AndroidAnnotations/androidannotations/src/test/resources/org/androidannotations/menu/AndroidManifest.xml index 137e424126..fd3b52360a 100644 --- a/AndroidAnnotations/androidannotations/src/test/resources/org/androidannotations/menu/AndroidManifest.xml +++ b/AndroidAnnotations/androidannotations/src/test/resources/org/androidannotations/menu/AndroidManifest.xml @@ -1,5 +1,6 @@ + true diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ParcelableSerializableData.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ParcelableSerializableData.java index 747b8ed9b5..d5ae931ff1 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ParcelableSerializableData.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ParcelableSerializableData.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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 java.io.Serializable; From 94acf915a2ba6cb33d5f73ce9d1bbcd3ee972000 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Mon, 10 Jun 2013 10:27:22 +0200 Subject: [PATCH 75/86] Format and organise import with eclipse --- .../AndroidAnnotationProcessor.java | 34 ++-- .../generation/ApiCodeGenerator.java | 11 +- .../generation/CodeModelGenerator.java | 8 +- .../generation/SourceCodewriter.java | 12 +- .../handler/AbstractListenerHandler.java | 34 ++-- .../handler/AbstractRunnableHandler.java | 8 +- .../handler/AbstractSeekBarTouchHandler.java | 21 ++- .../handler/AfterInjectHandler.java | 8 +- .../handler/AfterTextChangeHandler.java | 25 +-- .../handler/AfterViewsHandler.java | 8 +- .../handler/AnnotationHandler.java | 7 +- .../handler/AnnotationHandlers.java | 42 +++-- .../handler/AppHandler.java | 11 +- .../handler/BackgroundHandler.java | 21 +-- .../handler/BaseAnnotationHandler.java | 4 +- .../handler/BeanHandler.java | 23 +-- .../handler/BeforeTextChangeHandler.java | 24 +-- .../handler/CheckedChangeHandler.java | 19 ++- .../handler/ClickHandler.java | 18 ++- .../handler/CustomTitleHandler.java | 51 +++--- .../handler/EActivityHandler.java | 18 ++- .../handler/EApplicationHandler.java | 10 +- .../handler/EBeanHandler.java | 16 +- .../handler/EFragmentHandler.java | 25 +-- .../handler/EProviderHandler.java | 10 +- .../handler/EReceiverHandler.java | 10 +- .../handler/EServiceHandler.java | 12 +- .../handler/EViewGroupHandler.java | 15 +- .../handler/EViewHandler.java | 10 +- .../handler/ExtraHandler.java | 43 +++-- .../handler/FocusChangeHandler.java | 18 ++- .../handler/FragmentArgHandler.java | 27 +++- .../handler/FragmentByIdHandler.java | 23 +-- .../handler/FragmentByTagHandler.java | 20 ++- .../handler/FromHtmlHandler.java | 17 +- .../handler/FullscreenHandler.java | 35 +++-- .../handler/GeneratingAnnotationHandler.java | 4 +- .../HierarchyViewerSupportHandler.java | 11 +- .../handler/HttpsClientHandler.java | 28 +++- .../handler/InstanceStateHandler.java | 94 ++++++----- .../handler/ItemClickHandler.java | 23 ++- .../handler/ItemLongClickHandler.java | 24 ++- .../handler/ItemSelectHandler.java | 26 ++- .../handler/LongClickHandler.java | 19 ++- .../handler/NoTitleHandler.java | 36 +++-- .../NonConfigurationInstanceHandler.java | 21 ++- .../handler/OnActivityResultHandler.java | 22 +-- .../handler/OptionsItemHandler.java | 32 ++-- .../handler/OptionsMenuHandler.java | 16 +- .../handler/OptionsMenuItemHandler.java | 17 +- .../handler/OrmLiteDaoHandler.java | 18 ++- .../handler/PrefHandler.java | 22 +-- .../handler/ProduceHandler.java | 13 +- .../handler/ResHandler.java | 19 +-- .../handler/RoboGuiceHandler.java | 36 +++-- .../handler/RootContextHanlder.java | 19 +-- .../handler/SeekBarProgressChangeHandler.java | 24 +-- .../handler/SeekBarTouchStartHandler.java | 7 +- .../handler/SeekBarTouchStopHandler.java | 7 +- .../handler/SharedPrefHandler.java | 148 +++++++++++------- .../handler/SubscribeHandler.java | 13 +- .../handler/SystemServiceHandler.java | 17 +- .../handler/TextChangeHandler.java | 24 +-- .../handler/TouchHandler.java | 19 ++- .../handler/TraceHandler.java | 77 +++++---- .../handler/TransactionalHandler.java | 17 +- .../handler/UiThreadHandler.java | 14 +- .../handler/ViewByIdHandler.java | 19 +-- .../handler/WindowFeatureHandler.java | 7 +- .../helper/APTCodeModelHelper.java | 30 +++- .../helper/ActionBarSherlockHelper.java | 4 +- .../helper/ActivityIntentBuilder.java | 11 +- .../helper/AndroidManifestFinder.java | 25 +-- .../helper/AnnotationHelper.java | 64 ++++---- .../helper/BundleHelper.java | 13 +- .../helper/GreenDroidHelper.java | 15 +- .../helper/HoloEverywhereHelper.java | 4 +- .../helper/IdAnnotationHelper.java | 38 ++--- .../helper/IdValidatorHelper.java | 9 +- .../helper/IntentBuilder.java | 18 ++- .../helper/RestAnnotationHelper.java | 42 ++++- .../helper/ServiceIntentBuilder.java | 7 +- .../helper/TargetAnnotationHelper.java | 3 +- .../helper/ValidatorHelper.java | 68 ++++++-- .../helper/ValidatorParameterHelper.java | 9 +- .../helper/ViewNotifierHelper.java | 17 +- .../holder/BaseGeneratedClassHolder.java | 138 ++++++++-------- .../holder/EActivityHolder.java | 86 ++++++---- .../holder/EApplicationHolder.java | 32 ++-- .../holder/EBeanHolder.java | 31 ++-- .../holder/EComponentHolder.java | 27 ++-- .../EComponentWithViewSupportHolder.java | 31 +++- .../holder/EFragmentHolder.java | 62 +++++--- .../holder/EProviderHolder.java | 13 +- .../holder/EReceiverHolder.java | 13 +- .../holder/EServiceHolder.java | 18 ++- .../holder/EViewGroupHolder.java | 9 +- .../holder/EViewHolder.java | 35 +++-- .../holder/GeneratedClassHolder.java | 38 +++-- .../androidannotations/holder/HasExtras.java | 2 + .../holder/HasInstanceState.java | 15 +- .../holder/HasIntentBuilder.java | 2 + .../holder/HasOnActivityResult.java | 2 + .../holder/HasOptionsMenu.java | 4 + .../holder/InstanceStateHolder.java | 147 ++++++++--------- .../holder/NonConfigurationHolder.java | 8 +- .../holder/OnActivityResultHolder.java | 16 +- .../holder/OnSeekBarChangeListenerHolder.java | 6 +- .../androidannotations/holder/RestHolder.java | 76 ++++----- .../holder/RoboGuiceHolder.java | 3 +- .../holder/SharedPrefHolder.java | 36 +++-- .../holder/TextWatcherHolder.java | 7 +- .../androidannotations/model/AndroidRes.java | 22 ++- .../model/AndroidSystemServices.java | 10 +- .../model/ModelExtractor.java | 7 +- .../process/ModelProcessor.java | 26 +-- .../process/ModelValidator.java | 11 +- .../process/OriginatingElements.java | 3 +- .../process/ProcessHolder.java | 26 +-- .../rclass/CoumpoundInnerClass.java | 3 +- .../rclass/IRInnerClass.java | 3 +- .../rclass/RInnerClass.java | 40 +++-- .../shadows/CustomShadowBundle.java | 14 +- .../robolectric/shadows/ShadowButton.java | 3 +- .../shadows/ShadowListFragment.java | 13 +- .../test15/AbstractActivityTest.java | 2 +- .../test15/AndroidAnnotationsTestRunner.java | 7 +- .../ApplicationInjectedActivityTest.java | 13 +- .../test15/AwaitingResultActivityTest.java | 29 ++-- .../test15/ClicksHandledActivityTest.java | 35 +++-- .../test15/EmptyActivityWithLayoutTest.java | 3 +- .../test15/FakeClipboardManager.java | 4 +- .../test15/FromHtmlActivityTest.java | 6 +- .../test15/InjectExtraTest.java | 2 +- .../test15/ItemClicksHandledActivityTest.java | 35 +++-- .../test15/LongClicksHandledActivityTest.java | 3 +- .../test15/RobolectricParameterized.java | 49 ++++-- .../test15/SSLConnectionTest.java | 21 ++- .../test15/ServiceInjectionTest.java | 9 +- .../test15/ThreadActivityTest.java | 13 +- .../test15/TouchesHandledActivityTest.java | 18 ++- .../test15/TracedActivityTest.java | 69 ++++---- .../androidannotations/test15/ViewAssert.java | 3 +- .../test15/AbstractActivity.java | 6 +- .../test15/ActivityWithServices.java | 8 +- .../test15/ApplicationInjectedActivity.java | 4 +- .../test15/AwaitingResultActivity.java | 18 +-- .../test15/BackpressedActivity.java | 4 +- .../test15/CheckedChangeHandledActivity.java | 3 +- .../test15/ClicksHandledActivity.java | 8 +- .../test15/CustomTitleActivity.java | 6 +- .../test15/EmptyActivityWithLayout.java | 4 +- .../test15/EmptyActivityWithoutLayout.java | 4 +- .../test15/ExtendingActivity.java | 2 +- .../test15/ExtraInjectedActivity.java | 15 +- .../test15/FragmentArguments.java | 15 +- .../test15/FromHtmlActivity.java | 6 +- .../test15/HierarchyViewerActivity.java | 2 +- .../test15/ItemClicksHandledActivity.java | 23 +-- .../test15/LongClicksHandledActivity.java | 22 +-- .../test15/NoTitleFullscreenActivity.java | 5 +- .../test15/ParcelableSerializableData.java | 4 +- .../test15/SSLConnection.java | 5 +- .../test15/SeekBarChangeListenedActivity.java | 6 +- .../test15/TextWatchedActivity.java | 64 +++++--- .../test15/ThreadActivity.java | 35 +++-- .../test15/TouchesHandledActivity.java | 25 +-- .../test15/TracedActivity.java | 28 ++-- .../test15/TransactionalActivity.java | 9 +- .../test15/ViewsInjectedActivity.java | 8 +- 170 files changed, 2206 insertions(+), 1460 deletions(-) diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java index 126dcd763c..93839394ad 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java @@ -15,36 +15,42 @@ */ package org.androidannotations; +import static org.androidannotations.helper.AndroidManifestFinder.ANDROID_MANIFEST_FILE_OPTION; +import static org.androidannotations.helper.ModelConstants.TRACE_OPTION; + +import java.io.IOException; +import java.io.PrintWriter; +import java.io.StringWriter; +import java.util.Set; + +import javax.annotation.processing.AbstractProcessor; +import javax.annotation.processing.Messager; +import javax.annotation.processing.ProcessingEnvironment; +import javax.annotation.processing.RoundEnvironment; +import javax.annotation.processing.SupportedOptions; +import javax.annotation.processing.SupportedSourceVersion; +import javax.lang.model.SourceVersion; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; +import javax.tools.Diagnostic; + import org.androidannotations.generation.CodeModelGenerator; import org.androidannotations.handler.AnnotationHandlers; import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.AndroidManifestFinder; import org.androidannotations.helper.Option; -import org.androidannotations.process.TimeStats; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; import org.androidannotations.model.AnnotationElementsHolder; import org.androidannotations.model.ModelExtractor; import org.androidannotations.process.ModelProcessor; import org.androidannotations.process.ModelValidator; +import org.androidannotations.process.TimeStats; import org.androidannotations.rclass.AndroidRClassFinder; import org.androidannotations.rclass.CoumpoundRClass; import org.androidannotations.rclass.IRClass; import org.androidannotations.rclass.ProjectRClassFinder; -import javax.annotation.processing.*; -import javax.lang.model.SourceVersion; -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; -import javax.tools.Diagnostic; -import java.io.IOException; -import java.io.PrintWriter; -import java.io.StringWriter; -import java.util.Set; - -import static org.androidannotations.helper.AndroidManifestFinder.ANDROID_MANIFEST_FILE_OPTION; -import static org.androidannotations.helper.ModelConstants.TRACE_OPTION; - @SupportedSourceVersion(SourceVersion.RELEASE_6) @SupportedOptions({ TRACE_OPTION, ANDROID_MANIFEST_FILE_OPTION }) public class AndroidAnnotationProcessor extends AbstractProcessor { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/ApiCodeGenerator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/ApiCodeGenerator.java index c347aa6a83..5a8556060e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/ApiCodeGenerator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/ApiCodeGenerator.java @@ -15,16 +15,17 @@ */ package org.androidannotations.generation; -import org.androidannotations.process.OriginatingElements; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.util.Set; import javax.annotation.processing.Filer; import javax.annotation.processing.FilerException; import javax.lang.model.element.Element; import javax.tools.JavaFileObject; -import java.io.IOException; -import java.io.InputStream; -import java.io.OutputStream; -import java.util.Set; + +import org.androidannotations.process.OriginatingElements; public class ApiCodeGenerator { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/CodeModelGenerator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/CodeModelGenerator.java index c2da5da45c..def9155025 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/CodeModelGenerator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/CodeModelGenerator.java @@ -15,12 +15,14 @@ */ package org.androidannotations.generation; -import com.sun.codemodel.writer.PrologCodeWriter; -import org.androidannotations.process.ModelProcessor; +import java.io.IOException; import javax.annotation.processing.Filer; import javax.annotation.processing.Messager; -import java.io.IOException; + +import org.androidannotations.process.ModelProcessor; + +import com.sun.codemodel.writer.PrologCodeWriter; public class CodeModelGenerator { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/SourceCodewriter.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/SourceCodewriter.java index 3a31afc1a6..3c293af75e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/SourceCodewriter.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/SourceCodewriter.java @@ -15,9 +15,8 @@ */ package org.androidannotations.generation; -import com.sun.codemodel.CodeWriter; -import com.sun.codemodel.JPackage; -import org.androidannotations.process.OriginatingElements; +import java.io.IOException; +import java.io.OutputStream; import javax.annotation.processing.Filer; import javax.annotation.processing.FilerException; @@ -25,8 +24,11 @@ import javax.lang.model.element.Element; import javax.tools.Diagnostic.Kind; import javax.tools.JavaFileObject; -import java.io.IOException; -import java.io.OutputStream; + +import org.androidannotations.process.OriginatingElements; + +import com.sun.codemodel.CodeWriter; +import com.sun.codemodel.JPackage; public class SourceCodewriter extends CodeWriter { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java index b791b82f91..bff3ffa187 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java @@ -15,25 +15,39 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; +import static com.sun.codemodel.JExpr._new; +import static com.sun.codemodel.JExpr._null; +import static com.sun.codemodel.JExpr.cast; +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.AndroidManifest; import org.androidannotations.helper.IdAnnotationHelper; import org.androidannotations.helper.IdValidatorHelper; import org.androidannotations.holder.EComponentWithViewSupportHolder; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.IsValid; import org.androidannotations.process.ProcessHolder; import org.androidannotations.rclass.IRClass; -import org.androidannotations.process.IsValid; - -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 java.util.List; -import static com.sun.codemodel.JExpr.*; +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.JType; +import com.sun.codemodel.JVar; public abstract class AbstractListenerHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractRunnableHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractRunnableHandler.java index 25a19875d1..c6fb5cea7f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractRunnableHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractRunnableHandler.java @@ -15,14 +15,14 @@ */ package org.androidannotations.handler; -import org.androidannotations.holder.EComponentHolder; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.process.IsValid; - import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; import javax.lang.model.element.ExecutableElement; +import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.IsValid; + public abstract class AbstractRunnableHandler extends BaseAnnotationHandler { public AbstractRunnableHandler(Class targetClass, ProcessingEnvironment processingEnvironment) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractSeekBarTouchHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractSeekBarTouchHandler.java index 00ce8bb68a..9a1522ae15 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractSeekBarTouchHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractSeekBarTouchHandler.java @@ -15,7 +15,13 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; +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 org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.IdAnnotationHelper; import org.androidannotations.helper.IdValidatorHelper; @@ -23,14 +29,14 @@ import org.androidannotations.holder.OnSeekBarChangeListenerHolder; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.rclass.IRClass; import org.androidannotations.process.IsValid; +import org.androidannotations.rclass.IRClass; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.VariableElement; -import java.util.List; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JFieldRef; +import com.sun.codemodel.JInvocation; +import com.sun.codemodel.JVar; public abstract class AbstractSeekBarTouchHandler extends BaseAnnotationHandler { @@ -89,5 +95,6 @@ public void process(Element element, EComponentWithViewSupportHolder holder) thr } protected abstract JBlock getMethodBodyToCall(OnSeekBarChangeListenerHolder onSeekBarChangeListenerHolder); + protected abstract JVar getMethodParamToPass(OnSeekBarChangeListenerHolder onSeekBarChangeListenerHolder); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterInjectHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterInjectHandler.java index a6ebf7e9ff..e58768637d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterInjectHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterInjectHandler.java @@ -15,15 +15,15 @@ */ package org.androidannotations.handler; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; + import org.androidannotations.annotations.AfterInject; import org.androidannotations.holder.EComponentHolder; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.IsValid; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; - public class AfterInjectHandler extends BaseAnnotationHandler { public AfterInjectHandler(ProcessingEnvironment processingEnvironment) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterTextChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterTextChangeHandler.java index 6667a76d55..d0411f1695 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterTextChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterTextChangeHandler.java @@ -15,7 +15,14 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; +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.AfterTextChange; import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.CanonicalNameConstants; @@ -25,15 +32,14 @@ import org.androidannotations.holder.TextWatcherHolder; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.rclass.IRClass; import org.androidannotations.process.IsValid; +import org.androidannotations.rclass.IRClass; -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 java.util.List; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JFieldRef; +import com.sun.codemodel.JInvocation; +import com.sun.codemodel.JVar; public class AfterTextChangeHandler extends BaseAnnotationHandler { @@ -49,7 +55,6 @@ public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidS idAnnotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); } - @Override public boolean validate(Element element, AnnotationElements validatedElements) { IsValid valid = new IsValid(); @@ -96,7 +101,7 @@ public void process(Element element, EComponentWithViewSupportHolder holder) thr } List idsRefs = idAnnotationHelper.extractAnnotationFieldRefs(holder, element, IRClass.Res.ID, true); - + for (JFieldRef idRef : idsRefs) { TextWatcherHolder textWatcherHolder = holder.getTextWatcherHolder(idRef, viewParameterType); JBlock methodBody = textWatcherHolder.getAfterTextChangedBody(); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterViewsHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterViewsHandler.java index 82fa933083..251c55d0b2 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterViewsHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterViewsHandler.java @@ -15,15 +15,15 @@ */ package org.androidannotations.handler; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; + import org.androidannotations.annotations.AfterViews; import org.androidannotations.holder.EComponentWithViewSupportHolder; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.IsValid; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; - public class AfterViewsHandler extends BaseAnnotationHandler { public AfterViewsHandler(ProcessingEnvironment processingEnvironment) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandler.java index f1e56bd753..6b6d83436c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandler.java @@ -15,20 +15,23 @@ */ package org.androidannotations.handler; +import javax.lang.model.element.Element; + import org.androidannotations.helper.AndroidManifest; import org.androidannotations.holder.GeneratedClassHolder; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; import org.androidannotations.rclass.IRClass; -import javax.lang.model.element.Element; - public interface AnnotationHandler { String getTarget(); + boolean validate(Element element, AnnotationElements validatedElements); + void process(Element element, T holder) throws Exception; void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest); + void setValidatedModel(AnnotationElements validatedModel); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index bb3dc7f58b..0a06fb52d3 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -15,7 +15,25 @@ */ package org.androidannotations.handler; -import org.androidannotations.handler.rest.*; +import static org.androidannotations.helper.ModelConstants.TRACE_OPTION; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import javax.annotation.processing.ProcessingEnvironment; + +import org.androidannotations.handler.rest.DeleteHandler; +import org.androidannotations.handler.rest.GetHandler; +import org.androidannotations.handler.rest.HeadHandler; +import org.androidannotations.handler.rest.OptionsHandler; +import org.androidannotations.handler.rest.PostHandler; +import org.androidannotations.handler.rest.PutHandler; +import org.androidannotations.handler.rest.RestHandler; +import org.androidannotations.handler.rest.RestServiceHandler; import org.androidannotations.helper.AndroidManifest; import org.androidannotations.holder.GeneratedClassHolder; import org.androidannotations.model.AndroidRes; @@ -23,11 +41,6 @@ import org.androidannotations.model.AnnotationElements; import org.androidannotations.rclass.IRClass; -import javax.annotation.processing.ProcessingEnvironment; -import java.util.*; - -import static org.androidannotations.helper.ModelConstants.TRACE_OPTION; - public class AnnotationHandlers { private List> annotationHandlers = new ArrayList>(); @@ -35,7 +48,6 @@ public class AnnotationHandlers { private List> decoratingAnnotationHandlers = new ArrayList>(); private Set supportedAnnotationNames; - @SuppressWarnings("unchecked") public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new EApplicationHandler(processingEnvironment)); add(new EActivityHandler(processingEnvironment)); @@ -79,10 +91,10 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new OptionsMenuHandler(processingEnvironment)); add(new OptionsMenuItemHandler(processingEnvironment)); add(new OptionsItemHandler(processingEnvironment)); - add(new NoTitleHandler(processingEnvironment)); - add(new CustomTitleHandler(processingEnvironment)); - add(new FullscreenHandler(processingEnvironment)); - add(new RestServiceHandler(processingEnvironment)); + add(new NoTitleHandler(processingEnvironment)); + add(new CustomTitleHandler(processingEnvironment)); + add(new FullscreenHandler(processingEnvironment)); + add(new RestServiceHandler(processingEnvironment)); add(new OrmLiteDaoHandler(processingEnvironment)); add(new RootContextHanlder(processingEnvironment)); add(new NonConfigurationInstanceHandler(processingEnvironment)); @@ -97,7 +109,7 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new ProduceHandler(processingEnvironment)); add(new UiThreadHandler(processingEnvironment)); add(new BackgroundHandler(processingEnvironment)); - add(new InstanceStateHandler(processingEnvironment)); + add(new InstanceStateHandler(processingEnvironment)); add(new HttpsClientHandler(processingEnvironment)); add(new OnActivityResultHandler(processingEnvironment)); add(new HierarchyViewerSupportHandler(processingEnvironment)); @@ -135,13 +147,13 @@ public List> getDecorating() { } public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) { - for (AnnotationHandler annotationHandler : annotationHandlers) { + for (AnnotationHandler annotationHandler : annotationHandlers) { annotationHandler.setAndroidEnvironment(rClass, androidSystemServices, androidManifest); } } public void setValidatedModel(AnnotationElements validatedModel) { - for (AnnotationHandler annotationHandler : annotationHandlers) { + for (AnnotationHandler annotationHandler : annotationHandlers) { annotationHandler.setValidatedModel(validatedModel); } } @@ -159,7 +171,7 @@ private boolean traceActivated(ProcessingEnvironment processingEnvironment) { public Set getSupportedAnnotationTypes() { if (supportedAnnotationNames == null) { Set annotationNames = new HashSet(); - for (AnnotationHandler annotationHandler : annotationHandlers) { + for (AnnotationHandler annotationHandler : annotationHandlers) { annotationNames.add(annotationHandler.getTarget()); } supportedAnnotationNames = Collections.unmodifiableSet(annotationNames); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java index b9d85b2aac..5ebfbdce83 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java @@ -15,7 +15,11 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JClass; +import static com.sun.codemodel.JExpr.ref; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + import org.androidannotations.annotations.App; import org.androidannotations.annotations.EApplication; import org.androidannotations.helper.ModelConstants; @@ -24,10 +28,7 @@ import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.IsValid; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; - -import static com.sun.codemodel.JExpr.ref; +import com.sun.codemodel.JClass; public class AppHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BackgroundHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BackgroundHandler.java index e35bc9c9f2..72573147ab 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BackgroundHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BackgroundHandler.java @@ -15,21 +15,22 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JDefinedClass; -import com.sun.codemodel.JInvocation; -import com.sun.codemodel.JMethod; -import org.androidannotations.annotations.Background; -import org.androidannotations.api.BackgroundExecutor; -import org.androidannotations.helper.APTCodeModelHelper; -import org.androidannotations.holder.EComponentHolder; +import static com.sun.codemodel.JExpr._new; +import static com.sun.codemodel.JExpr.lit; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; import javax.lang.model.element.ExecutableElement; -import static com.sun.codemodel.JExpr._new; -import static com.sun.codemodel.JExpr.lit; +import org.androidannotations.annotations.Background; +import org.androidannotations.api.BackgroundExecutor; +import org.androidannotations.helper.APTCodeModelHelper; +import org.androidannotations.holder.EComponentHolder; + +import com.sun.codemodel.JClass; +import com.sun.codemodel.JDefinedClass; +import com.sun.codemodel.JInvocation; +import com.sun.codemodel.JMethod; public class BackgroundHandler extends AbstractRunnableHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BaseAnnotationHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BaseAnnotationHandler.java index 34c65caf81..3f4bb69e20 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BaseAnnotationHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BaseAnnotationHandler.java @@ -15,6 +15,8 @@ */ package org.androidannotations.handler; +import javax.annotation.processing.ProcessingEnvironment; + import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.IdAnnotationHelper; import org.androidannotations.helper.IdValidatorHelper; @@ -23,8 +25,6 @@ import org.androidannotations.model.AnnotationElements; import org.androidannotations.rclass.IRClass; -import javax.annotation.processing.ProcessingEnvironment; - public abstract class BaseAnnotationHandler implements AnnotationHandler { private final String target; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java index c5edb66861..390c26cf14 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java @@ -15,10 +15,14 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JFieldRef; -import com.sun.codemodel.JInvocation; +import static com.sun.codemodel.JExpr._null; +import static com.sun.codemodel.JExpr.ref; +import static org.androidannotations.helper.ModelConstants.GENERATION_SUFFIX; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.type.TypeMirror; + import org.androidannotations.annotations.Bean; import org.androidannotations.annotations.EBean; import org.androidannotations.annotations.NonConfigurationInstance; @@ -28,13 +32,10 @@ import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.IsValid; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.type.TypeMirror; - -import static com.sun.codemodel.JExpr._null; -import static com.sun.codemodel.JExpr.ref; -import static org.androidannotations.helper.ModelConstants.GENERATION_SUFFIX; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JFieldRef; +import com.sun.codemodel.JInvocation; public class BeanHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeforeTextChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeforeTextChangeHandler.java index 236082de62..9dcf4b026e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeforeTextChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeforeTextChangeHandler.java @@ -15,7 +15,15 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; +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.BeforeTextChange; import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.CanonicalNameConstants; @@ -25,16 +33,14 @@ import org.androidannotations.holder.TextWatcherHolder; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.rclass.IRClass; import org.androidannotations.process.IsValid; +import org.androidannotations.rclass.IRClass; -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 java.util.List; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JFieldRef; +import com.sun.codemodel.JInvocation; +import com.sun.codemodel.JVar; public class BeforeTextChangeHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CheckedChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CheckedChangeHandler.java index b3fdb860ed..e61ea81c13 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CheckedChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CheckedChangeHandler.java @@ -15,17 +15,26 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; -import org.androidannotations.annotations.CheckedChange; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.process.IsValid; +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 java.util.List; + +import org.androidannotations.annotations.CheckedChange; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.IsValid; + +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.JType; +import com.sun.codemodel.JVar; public class CheckedChangeHandler extends AbstractListenerHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ClickHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ClickHandler.java index 52fc892f4b..4e10d400a8 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ClickHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ClickHandler.java @@ -15,17 +15,25 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; -import org.androidannotations.annotations.Click; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.process.IsValid; +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 java.util.List; + +import org.androidannotations.annotations.Click; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.IsValid; + +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 ClickHandler extends AbstractListenerHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java index ec9daaf49d..c9bc8f4a4e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java @@ -15,47 +15,48 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JFieldRef; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + import org.androidannotations.annotations.CustomTitle; import org.androidannotations.helper.AnnotationHelper; import org.androidannotations.helper.IdValidatorHelper; import org.androidannotations.holder.EActivityHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.rclass.IRClass; import org.androidannotations.process.IsValid; +import org.androidannotations.rclass.IRClass; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JFieldRef; public class CustomTitleHandler extends BaseAnnotationHandler { - private final AnnotationHelper annotationHelper; + private final AnnotationHelper annotationHelper; - public CustomTitleHandler(ProcessingEnvironment processingEnvironment) { - super(CustomTitle.class, processingEnvironment); - annotationHelper = new AnnotationHelper(processingEnv); - } + public CustomTitleHandler(ProcessingEnvironment processingEnvironment) { + super(CustomTitle.class, processingEnvironment); + annotationHelper = new AnnotationHelper(processingEnv); + } - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); - validatorHelper.hasEActivity(element, validatedElements, valid); + validatorHelper.hasEActivity(element, validatedElements, valid); - validatorHelper.resIdsExist(element, IRClass.Res.LAYOUT, IdValidatorHelper.FallbackStrategy.NEED_RES_ID, valid); + validatorHelper.resIdsExist(element, IRClass.Res.LAYOUT, IdValidatorHelper.FallbackStrategy.NEED_RES_ID, valid); - return valid.isValid(); - } + return valid.isValid(); + } - @Override - public void process(Element element, EActivityHolder holder) { - JBlock onViewChangedBody = holder.getOnViewChangedBody(); + @Override + public void process(Element element, EActivityHolder holder) { + JBlock onViewChangedBody = holder.getOnViewChangedBody(); - JFieldRef contentViewId = annotationHelper.extractAnnotationFieldRefs(holder, element, getTarget(), rClass.get(IRClass.Res.LAYOUT), false).get(0); + JFieldRef contentViewId = annotationHelper.extractAnnotationFieldRefs(holder, element, getTarget(), rClass.get(IRClass.Res.LAYOUT), false).get(0); - JFieldRef customTitleFeature = holder.classes().WINDOW.staticRef("FEATURE_CUSTOM_TITLE"); - holder.getInitBody().invoke("requestWindowFeature").arg(customTitleFeature); - onViewChangedBody.add(holder.getContextRef().invoke("getWindow").invoke("setFeatureInt").arg(customTitleFeature).arg(contentViewId)); - } + JFieldRef customTitleFeature = holder.classes().WINDOW.staticRef("FEATURE_CUSTOM_TITLE"); + holder.getInitBody().invoke("requestWindowFeature").arg(customTitleFeature); + onViewChangedBody.add(holder.getContextRef().invoke("getWindow").invoke("setFeatureInt").arg(customTitleFeature).arg(contentViewId)); + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EActivityHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EActivityHandler.java index 14f9553245..b31b0fc8a2 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EActivityHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EActivityHandler.java @@ -15,22 +15,24 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JFieldRef; -import com.sun.codemodel.JMethod; +import java.util.List; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; + import org.androidannotations.annotations.EActivity; import org.androidannotations.helper.AnnotationHelper; import org.androidannotations.helper.IdValidatorHelper; import org.androidannotations.holder.EActivityHolder; import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.IsValid; import org.androidannotations.process.ProcessHolder; import org.androidannotations.rclass.IRClass; -import org.androidannotations.process.IsValid; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; -import java.util.List; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JFieldRef; +import com.sun.codemodel.JMethod; public class EActivityHandler extends BaseAnnotationHandler implements GeneratingAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EApplicationHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EApplicationHandler.java index d7e49181d1..94b3d32b6b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EApplicationHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EApplicationHandler.java @@ -15,15 +15,15 @@ */ package org.androidannotations.handler; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; + import org.androidannotations.annotations.EApplication; import org.androidannotations.holder.EApplicationHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.process.ProcessHolder; import org.androidannotations.process.IsValid; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; +import org.androidannotations.process.ProcessHolder; public class EApplicationHandler extends BaseAnnotationHandler implements GeneratingAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EBeanHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EBeanHandler.java index b3772c1d79..e4d77569a5 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EBeanHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EBeanHandler.java @@ -15,15 +15,15 @@ */ package org.androidannotations.handler; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; + import org.androidannotations.annotations.EBean; import org.androidannotations.holder.EBeanHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.process.ProcessHolder; import org.androidannotations.process.IsValid; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; +import org.androidannotations.process.ProcessHolder; public class EBeanHandler extends BaseAnnotationHandler implements GeneratingAnnotationHandler { @@ -32,7 +32,7 @@ public EBeanHandler(ProcessingEnvironment processingEnvironment) { } @Override - public EBeanHolder createGeneratedClassHolder(ProcessHolder processHolder, TypeElement annotatedComponent) throws Exception{ + public EBeanHolder createGeneratedClassHolder(ProcessHolder processHolder, TypeElement annotatedComponent) throws Exception { return new EBeanHolder(processHolder, annotatedComponent); } @@ -55,10 +55,10 @@ public void process(Element element, EBeanHolder holder) { EBean.Scope eBeanScope = eBeanAnnotation.scope(); boolean hasSingletonScope = eBeanScope == EBean.Scope.Singleton; - holder.createFactoryMethod(hasSingletonScope); + holder.createFactoryMethod(hasSingletonScope); if (!hasSingletonScope) { - holder.createRebindMethod(); + holder.createRebindMethod(); } } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EFragmentHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EFragmentHandler.java index 08e7a67d68..d671fd2987 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EFragmentHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EFragmentHandler.java @@ -15,25 +15,26 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JFieldRef; -import com.sun.codemodel.JFieldVar; -import com.sun.codemodel.JVar; +import static com.sun.codemodel.JExpr.FALSE; +import static com.sun.codemodel.JExpr._null; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; + import org.androidannotations.annotations.EFragment; import org.androidannotations.helper.IdAnnotationHelper; import org.androidannotations.helper.IdValidatorHelper; import org.androidannotations.holder.EFragmentHolder; import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.IsValid; import org.androidannotations.process.ProcessHolder; import org.androidannotations.rclass.IRClass; -import org.androidannotations.process.IsValid; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; -import static com.sun.codemodel.JExpr.FALSE; -import static com.sun.codemodel.JExpr._null; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JFieldRef; +import com.sun.codemodel.JFieldVar; +import com.sun.codemodel.JVar; public class EFragmentHandler extends BaseAnnotationHandler implements GeneratingAnnotationHandler { @@ -74,7 +75,7 @@ public void process(Element element, EFragmentHolder holder) { JBlock block = holder.getSetContentViewBlock(); JVar inflater = holder.getInflater(); - JVar container = holder.getContainer(); + JVar container = holder.getContainer(); JFieldVar contentView = holder.getContentView(); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EProviderHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EProviderHandler.java index 997a4795ff..9e61c9e5f4 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EProviderHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EProviderHandler.java @@ -15,15 +15,15 @@ */ package org.androidannotations.handler; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; + import org.androidannotations.annotations.EProvider; import org.androidannotations.holder.EProviderHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.process.ProcessHolder; import org.androidannotations.process.IsValid; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; +import org.androidannotations.process.ProcessHolder; public class EProviderHandler extends BaseAnnotationHandler implements GeneratingAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EReceiverHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EReceiverHandler.java index 8e73b15d8c..957aa7cb7f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EReceiverHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EReceiverHandler.java @@ -15,15 +15,15 @@ */ package org.androidannotations.handler; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; + import org.androidannotations.annotations.EReceiver; import org.androidannotations.holder.EReceiverHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.process.ProcessHolder; import org.androidannotations.process.IsValid; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; +import org.androidannotations.process.ProcessHolder; public class EReceiverHandler extends BaseAnnotationHandler implements GeneratingAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EServiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EServiceHandler.java index 7a1dde3950..3677ff29c7 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EServiceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EServiceHandler.java @@ -15,15 +15,15 @@ */ package org.androidannotations.handler; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; + import org.androidannotations.annotations.EService; import org.androidannotations.holder.EServiceHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.process.ProcessHolder; import org.androidannotations.process.IsValid; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; +import org.androidannotations.process.ProcessHolder; public class EServiceHandler extends BaseAnnotationHandler implements GeneratingAnnotationHandler { @@ -51,6 +51,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { @Override public void process(Element element, EServiceHolder holder) { - /* Do nothing */ + /* Do nothing */ } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewGroupHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewGroupHandler.java index 1c4d5c4163..b2a3c6ced8 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewGroupHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewGroupHandler.java @@ -15,8 +15,10 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JFieldRef; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; + import org.androidannotations.annotations.EViewGroup; import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.IdAnnotationHelper; @@ -24,13 +26,12 @@ import org.androidannotations.holder.EViewGroupHolder; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.IsValid; import org.androidannotations.process.ProcessHolder; import org.androidannotations.rclass.IRClass; -import org.androidannotations.process.IsValid; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JFieldRef; public class EViewGroupHandler extends BaseAnnotationHandler implements GeneratingAnnotationHandler { @@ -68,7 +69,7 @@ public boolean validate(Element element, AnnotationElements validatedElements) { public void process(Element element, EViewGroupHolder holder) { JFieldRef contentViewId = annotationHelper.extractOneAnnotationFieldRef(holder, element, IRClass.Res.LAYOUT, false); if (contentViewId != null) { - holder.getSetContentViewBlock().invoke("inflate").arg(holder.getContextRef()).arg(contentViewId).arg(JExpr._this()); + holder.getSetContentViewBlock().invoke("inflate").arg(holder.getContextRef()).arg(contentViewId).arg(JExpr._this()); } } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewHandler.java index 8384acdfda..87ae3d6b0b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewHandler.java @@ -15,15 +15,15 @@ */ package org.androidannotations.handler; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; + import org.androidannotations.annotations.EView; import org.androidannotations.holder.EViewHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.process.ProcessHolder; import org.androidannotations.process.IsValid; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; +import org.androidannotations.process.ProcessHolder; public class EViewHandler extends BaseAnnotationHandler implements GeneratingAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java index 1a9c1e93a3..adadca133f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java @@ -15,7 +15,24 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; +import static com.sun.codemodel.JExpr._this; +import static com.sun.codemodel.JExpr.cast; +import static com.sun.codemodel.JExpr.invoke; +import static com.sun.codemodel.JExpr.lit; +import static com.sun.codemodel.JMod.FINAL; +import static com.sun.codemodel.JMod.PUBLIC; +import static com.sun.codemodel.JMod.STATIC; +import static org.androidannotations.helper.CanonicalNameConstants.PARCELABLE; +import static org.androidannotations.helper.CanonicalNameConstants.SERIALIZABLE; +import static org.androidannotations.helper.CanonicalNameConstants.STRING; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.type.TypeKind; +import javax.lang.model.type.TypeMirror; +import javax.lang.model.util.Elements; +import javax.lang.model.util.Types; + import org.androidannotations.annotations.Extra; import org.androidannotations.helper.APTCodeModelHelper; import org.androidannotations.helper.AnnotationHelper; @@ -26,16 +43,16 @@ import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.IsValid; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.type.TypeKind; -import javax.lang.model.type.TypeMirror; -import javax.lang.model.util.Elements; -import javax.lang.model.util.Types; - -import static com.sun.codemodel.JExpr.*; -import static com.sun.codemodel.JMod.*; -import static org.androidannotations.helper.CanonicalNameConstants.*; +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.JFieldRef; +import com.sun.codemodel.JFieldVar; +import com.sun.codemodel.JInvocation; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JVar; public class ExtraHandler extends BaseAnnotationHandler { @@ -114,8 +131,8 @@ private void injectExtraInComponent(Element element, HasExtras hasExtras, JField } /* - * Handle the android bug : - * getIntent().getExtras().getByteArray() always returns null; + * Handle the android bug : getIntent().getExtras().getByteArray() + * always returns null; */ restoreMethodCall = handleByteArrayExtraBug(element, extraKeyStaticField, restoreMethodCall); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FocusChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FocusChangeHandler.java index 72b03d9c0b..282b301f83 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FocusChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FocusChangeHandler.java @@ -15,17 +15,25 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; -import org.androidannotations.annotations.FocusChange; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.process.IsValid; +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 java.util.List; + +import org.androidannotations.annotations.FocusChange; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.IsValid; + +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 FocusChangeHandler extends AbstractListenerHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentArgHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentArgHandler.java index fec73651f1..5b92496211 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentArgHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentArgHandler.java @@ -15,7 +15,16 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; +import static com.sun.codemodel.JExpr._this; +import static com.sun.codemodel.JExpr.lit; +import static com.sun.codemodel.JMod.FINAL; +import static com.sun.codemodel.JMod.PUBLIC; +import static com.sun.codemodel.JMod.STATIC; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.type.TypeMirror; + import org.androidannotations.annotations.FragmentArg; import org.androidannotations.helper.APTCodeModelHelper; import org.androidannotations.helper.AnnotationHelper; @@ -25,13 +34,15 @@ import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.IsValid; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.type.TypeMirror; - -import static com.sun.codemodel.JExpr._this; -import static com.sun.codemodel.JExpr.lit; -import static com.sun.codemodel.JMod.*; +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.JFieldRef; +import com.sun.codemodel.JFieldVar; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JVar; public class FragmentArgHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java index 5fb6a4a23a..d764e12fd7 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java @@ -15,9 +15,15 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JFieldRef; -import com.sun.codemodel.JMethod; +import static com.sun.codemodel.JExpr.cast; +import static com.sun.codemodel.JExpr.invoke; +import static com.sun.codemodel.JExpr.ref; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; +import javax.lang.model.type.TypeMirror; + import org.androidannotations.annotations.FragmentById; import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.CanonicalNameConstants; @@ -26,15 +32,12 @@ import org.androidannotations.holder.EComponentWithViewSupportHolder; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.rclass.IRClass; import org.androidannotations.process.IsValid; +import org.androidannotations.rclass.IRClass; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; -import javax.lang.model.type.TypeMirror; - -import static com.sun.codemodel.JExpr.*; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JFieldRef; +import com.sun.codemodel.JMethod; public class FragmentByIdHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java index 381a49b67c..b97d5f78c2 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java @@ -15,8 +15,15 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JMethod; +import static com.sun.codemodel.JExpr.cast; +import static com.sun.codemodel.JExpr.invoke; +import static com.sun.codemodel.JExpr.lit; +import static com.sun.codemodel.JExpr.ref; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.type.TypeMirror; + import org.androidannotations.annotations.FragmentByTag; import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.CanonicalNameConstants; @@ -24,14 +31,11 @@ import org.androidannotations.holder.EComponentWithViewSupportHolder; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.rclass.IRClass; import org.androidannotations.process.IsValid; +import org.androidannotations.rclass.IRClass; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.type.TypeMirror; - -import static com.sun.codemodel.JExpr.*; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JMethod; public class FragmentByTagHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java index e75a0386cb..7d45af5e9e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java @@ -15,8 +15,12 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JFieldRef; +import static com.sun.codemodel.JExpr._null; +import static com.sun.codemodel.JExpr.ref; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + import org.androidannotations.annotations.FromHtml; import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.IdAnnotationHelper; @@ -24,15 +28,12 @@ import org.androidannotations.holder.EComponentWithViewSupportHolder; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.IsValid; import org.androidannotations.process.ProcessHolder; import org.androidannotations.rclass.IRClass; -import org.androidannotations.process.IsValid; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import static com.sun.codemodel.JExpr._null; -import static com.sun.codemodel.JExpr.ref; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JFieldRef; public class FromHtmlHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java index 220b09485b..a33343b092 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java @@ -15,33 +15,34 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JFieldRef; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + import org.androidannotations.annotations.Fullscreen; import org.androidannotations.holder.EActivityHolder; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.IsValid; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; +import com.sun.codemodel.JFieldRef; public class FullscreenHandler extends BaseAnnotationHandler { - public FullscreenHandler(ProcessingEnvironment processingEnvironment) { - super(Fullscreen.class, processingEnvironment); - } + public FullscreenHandler(ProcessingEnvironment processingEnvironment) { + super(Fullscreen.class, processingEnvironment); + } - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); - validatorHelper.hasEActivity(element, validatedElements, valid); + validatorHelper.hasEActivity(element, validatedElements, valid); - return valid.isValid(); - } + return valid.isValid(); + } - @Override - public void process(Element element, EActivityHolder holder) { - JFieldRef fullScreen = holder.classes().WINDOW_MANAGER_LAYOUT_PARAMS.staticRef("FLAG_FULLSCREEN"); - holder.getInitBody().invoke("getWindow").invoke("setFlags").arg(fullScreen).arg(fullScreen); - } + @Override + public void process(Element element, EActivityHolder holder) { + JFieldRef fullScreen = holder.classes().WINDOW_MANAGER_LAYOUT_PARAMS.staticRef("FLAG_FULLSCREEN"); + holder.getInitBody().invoke("getWindow").invoke("setFlags").arg(fullScreen).arg(fullScreen); + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/GeneratingAnnotationHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/GeneratingAnnotationHandler.java index ca48b52db8..1de8fff9e1 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/GeneratingAnnotationHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/GeneratingAnnotationHandler.java @@ -15,11 +15,11 @@ */ package org.androidannotations.handler; +import javax.lang.model.element.TypeElement; + import org.androidannotations.holder.GeneratedClassHolder; import org.androidannotations.process.ProcessHolder; -import javax.lang.model.element.TypeElement; - public interface GeneratingAnnotationHandler extends AnnotationHandler { T createGeneratedClassHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HierarchyViewerSupportHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HierarchyViewerSupportHandler.java index d40b6344ba..743ec4d6d9 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HierarchyViewerSupportHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HierarchyViewerSupportHandler.java @@ -15,17 +15,18 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JInvocation; +import static com.sun.codemodel.JExpr._this; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + import org.androidannotations.annotations.HierarchyViewerSupport; import org.androidannotations.api.ViewServer; import org.androidannotations.holder.EActivityHolder; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.IsValid; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; - -import static com.sun.codemodel.JExpr._this; +import com.sun.codemodel.JInvocation; public class HierarchyViewerSupportHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java index 370ee12f45..4bcf8c0af3 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java @@ -15,20 +15,36 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; +import static com.sun.codemodel.JExpr._new; +import static com.sun.codemodel.JExpr._null; +import static com.sun.codemodel.JExpr._super; +import static com.sun.codemodel.JExpr.cast; +import static com.sun.codemodel.JExpr.invoke; +import static com.sun.codemodel.JExpr.lit; +import static com.sun.codemodel.JExpr.ref; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + import org.androidannotations.annotations.HttpsClient; import org.androidannotations.annotations.ResId; import org.androidannotations.holder.EComponentHolder; import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.IsValid; import org.androidannotations.process.ProcessHolder; import org.androidannotations.rclass.IRClass; import org.androidannotations.rclass.IRInnerClass; -import org.androidannotations.process.IsValid; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import static com.sun.codemodel.JExpr.*; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JCatchBlock; +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.JTryBlock; +import com.sun.codemodel.JVar; public class HttpsClientHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/InstanceStateHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/InstanceStateHandler.java index 2dc21c8259..c9d6ba27b5 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/InstanceStateHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/InstanceStateHandler.java @@ -15,7 +15,11 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; +import static com.sun.codemodel.JExpr.ref; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + import org.androidannotations.annotations.InstanceState; import org.androidannotations.helper.APTCodeModelHelper; import org.androidannotations.helper.AnnotationHelper; @@ -24,62 +28,66 @@ import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.IsValid; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; - -import static com.sun.codemodel.JExpr.ref; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +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.JVar; public class InstanceStateHandler extends BaseAnnotationHandler { - public InstanceStateHandler(ProcessingEnvironment processingEnvironment) { - super(InstanceState.class, processingEnvironment); - } + public InstanceStateHandler(ProcessingEnvironment processingEnvironment) { + super(InstanceState.class, processingEnvironment); + } - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); - validatorHelper.enclosingElementHasEActivityOrEFragment(element, validatedElements, valid); + validatorHelper.enclosingElementHasEActivityOrEFragment(element, validatedElements, valid); - validatorHelper.isNotPrivate(element, valid); + validatorHelper.isNotPrivate(element, valid); - validatorHelper.canBeSavedAsInstanceState(element, valid); + validatorHelper.canBeSavedAsInstanceState(element, valid); - return valid.isValid(); - } + return valid.isValid(); + } - @Override - public void process(Element element, HasInstanceState holder) { - String fieldName = element.getSimpleName().toString(); + @Override + public void process(Element element, HasInstanceState holder) { + String fieldName = element.getSimpleName().toString(); - JBlock saveStateBody = holder.getSaveStateMethodBody(); - JVar saveStateBundleParam = holder.getSaveStateBundleParam(); - JMethod restoreStateMethod = holder.getRestoreStateMethod(); - JBlock restoreStateBody = restoreStateMethod.body(); - JVar restoreStateBundleParam = holder.getRestoreStateBundleParam(); + JBlock saveStateBody = holder.getSaveStateMethodBody(); + JVar saveStateBundleParam = holder.getSaveStateBundleParam(); + JMethod restoreStateMethod = holder.getRestoreStateMethod(); + JBlock restoreStateBody = restoreStateMethod.body(); + JVar restoreStateBundleParam = holder.getRestoreStateBundleParam(); - AnnotationHelper annotationHelper = new AnnotationHelper(processingEnv); - BundleHelper bundleHelper = new BundleHelper(annotationHelper, element); - APTCodeModelHelper codeModelHelper = new APTCodeModelHelper(); + AnnotationHelper annotationHelper = new AnnotationHelper(processingEnv); + BundleHelper bundleHelper = new BundleHelper(annotationHelper, element); + APTCodeModelHelper codeModelHelper = new APTCodeModelHelper(); - JFieldRef ref = ref(fieldName); - saveStateBody.invoke(saveStateBundleParam, bundleHelper.getMethodNameToSave()).arg(fieldName).arg(ref); + JFieldRef ref = ref(fieldName); + saveStateBody.invoke(saveStateBundleParam, bundleHelper.getMethodNameToSave()).arg(fieldName).arg(ref); - JInvocation restoreMethodCall = JExpr.invoke(restoreStateBundleParam, bundleHelper.getMethodNameToRestore()).arg(fieldName); - if (bundleHelper.restoreCallNeedCastStatement()) { + JInvocation restoreMethodCall = JExpr.invoke(restoreStateBundleParam, bundleHelper.getMethodNameToRestore()).arg(fieldName); + if (bundleHelper.restoreCallNeedCastStatement()) { - JClass jclass = codeModelHelper.typeMirrorToJClass(element.asType(), holder); - JExpression castStatement = JExpr.cast(jclass, restoreMethodCall); - restoreStateBody.assign(ref, castStatement); + JClass jclass = codeModelHelper.typeMirrorToJClass(element.asType(), holder); + JExpression castStatement = JExpr.cast(jclass, restoreMethodCall); + restoreStateBody.assign(ref, castStatement); - if (bundleHelper.restoreCallNeedsSuppressWarning()) { - if (restoreStateMethod.annotations().size() == 0) { - restoreStateMethod.annotate(SuppressWarnings.class).param("value", "unchecked"); - } - } + if (bundleHelper.restoreCallNeedsSuppressWarning()) { + if (restoreStateMethod.annotations().size() == 0) { + restoreStateMethod.annotate(SuppressWarnings.class).param("value", "unchecked"); + } + } - } else { - restoreStateBody.assign(ref, restoreMethodCall); - } - } + } else { + restoreStateBody.assign(ref, restoreMethodCall); + } + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemClickHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemClickHandler.java index 484aba76d0..1d16a9b9f9 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemClickHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemClickHandler.java @@ -15,10 +15,10 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; -import org.androidannotations.annotations.ItemClick; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.process.IsValid; +import static com.sun.codemodel.JExpr.cast; +import static com.sun.codemodel.JExpr.invoke; + +import java.util.List; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; @@ -26,10 +26,19 @@ import javax.lang.model.element.VariableElement; import javax.lang.model.type.TypeKind; import javax.lang.model.type.TypeMirror; -import java.util.List; -import static com.sun.codemodel.JExpr.cast; -import static com.sun.codemodel.JExpr.invoke; +import org.androidannotations.annotations.ItemClick; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.IsValid; + +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.JType; +import com.sun.codemodel.JVar; public class ItemClickHandler extends AbstractListenerHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemLongClickHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemLongClickHandler.java index 18538b5160..89c72a48d0 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemLongClickHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemLongClickHandler.java @@ -15,10 +15,10 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; -import org.androidannotations.annotations.ItemLongClick; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.process.IsValid; +import static com.sun.codemodel.JExpr.cast; +import static com.sun.codemodel.JExpr.invoke; + +import java.util.List; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; @@ -26,10 +26,20 @@ import javax.lang.model.element.VariableElement; import javax.lang.model.type.TypeKind; import javax.lang.model.type.TypeMirror; -import java.util.List; -import static com.sun.codemodel.JExpr.cast; -import static com.sun.codemodel.JExpr.invoke; +import org.androidannotations.annotations.ItemLongClick; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.IsValid; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JDefinedClass; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JInvocation; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JMod; +import com.sun.codemodel.JType; +import com.sun.codemodel.JVar; public class ItemLongClickHandler extends AbstractListenerHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemSelectHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemSelectHandler.java index e01db5ea9b..bf0a472a56 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemSelectHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemSelectHandler.java @@ -15,10 +15,11 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; -import org.androidannotations.annotations.ItemSelect; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.process.IsValid; +import static com.sun.codemodel.JExpr._null; +import static com.sun.codemodel.JExpr.invoke; +import static com.sun.codemodel.JExpr.lit; + +import java.util.List; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; @@ -26,11 +27,20 @@ import javax.lang.model.element.VariableElement; import javax.lang.model.type.TypeKind; import javax.lang.model.type.TypeMirror; -import java.util.List; -import static com.sun.codemodel.JExpr._null; -import static com.sun.codemodel.JExpr.invoke; -import static com.sun.codemodel.JExpr.lit; +import org.androidannotations.annotations.ItemSelect; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.IsValid; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JDefinedClass; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JInvocation; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JMod; +import com.sun.codemodel.JType; +import com.sun.codemodel.JVar; public class ItemSelectHandler extends AbstractListenerHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/LongClickHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/LongClickHandler.java index e397cef142..172827d497 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/LongClickHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/LongClickHandler.java @@ -15,10 +15,7 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; -import org.androidannotations.annotations.LongClick; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.process.IsValid; +import java.util.List; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; @@ -26,7 +23,19 @@ import javax.lang.model.element.VariableElement; import javax.lang.model.type.TypeKind; import javax.lang.model.type.TypeMirror; -import java.util.List; + +import org.androidannotations.annotations.LongClick; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.IsValid; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JDefinedClass; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JInvocation; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JMod; +import com.sun.codemodel.JVar; public class LongClickHandler extends AbstractListenerHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java index 10886e2d83..3937071c6e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java @@ -15,34 +15,36 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JFieldRef; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + import org.androidannotations.annotations.NoTitle; import org.androidannotations.holder.EActivityHolder; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.IsValid; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; +import com.sun.codemodel.JFieldRef; +@SuppressWarnings("deprecation") public class NoTitleHandler extends BaseAnnotationHandler { - public NoTitleHandler(ProcessingEnvironment processingEnvironment) { - super(NoTitle.class, processingEnvironment); - } + public NoTitleHandler(ProcessingEnvironment processingEnvironment) { + super(NoTitle.class, processingEnvironment); + } - @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); - validatorHelper.hasEActivity(element, validatedElements, valid); + validatorHelper.hasEActivity(element, validatedElements, valid); - return valid.isValid(); - } + return valid.isValid(); + } - @Override - public void process(Element element, EActivityHolder holder) { - JFieldRef noTitle = holder.classes().WINDOW.staticRef("FEATURE_NO_TITLE"); + @Override + public void process(Element element, EActivityHolder holder) { + JFieldRef noTitle = holder.classes().WINDOW.staticRef("FEATURE_NO_TITLE"); - holder.getInitBody().invoke("requestWindowFeature").arg(noTitle); - } + holder.getInitBody().invoke("requestWindowFeature").arg(noTitle); + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NonConfigurationInstanceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NonConfigurationInstanceHandler.java index 3bb5e1f5a8..faed6fba02 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NonConfigurationInstanceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NonConfigurationInstanceHandler.java @@ -15,7 +15,15 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; +import static com.sun.codemodel.JExpr._this; +import static com.sun.codemodel.JExpr.cast; +import static com.sun.codemodel.JExpr.ref; +import static org.androidannotations.helper.ModelConstants.GENERATION_SUFFIX; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.type.TypeMirror; + import org.androidannotations.annotations.Bean; import org.androidannotations.annotations.NonConfigurationInstance; import org.androidannotations.helper.APTCodeModelHelper; @@ -25,12 +33,11 @@ import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.IsValid; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.type.TypeMirror; - -import static com.sun.codemodel.JExpr.*; -import static org.androidannotations.helper.ModelConstants.GENERATION_SUFFIX; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JClassAlreadyExistsException; +import com.sun.codemodel.JFieldVar; +import com.sun.codemodel.JVar; public class NonConfigurationInstanceHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OnActivityResultHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OnActivityResultHandler.java index c78ac9e67d..75bb137b10 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OnActivityResultHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OnActivityResultHandler.java @@ -15,15 +15,7 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JExpression; -import com.sun.codemodel.JInvocation; -import com.sun.codemodel.JVar; -import org.androidannotations.annotations.OnActivityResult; -import org.androidannotations.helper.CanonicalNameConstants; -import org.androidannotations.holder.HasOnActivityResult; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.process.IsValid; +import java.util.List; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; @@ -31,7 +23,17 @@ import javax.lang.model.element.VariableElement; import javax.lang.model.type.TypeKind; import javax.lang.model.type.TypeMirror; -import java.util.List; + +import org.androidannotations.annotations.OnActivityResult; +import org.androidannotations.helper.CanonicalNameConstants; +import org.androidannotations.holder.HasOnActivityResult; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.IsValid; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JInvocation; +import com.sun.codemodel.JVar; public class OnActivityResultHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsItemHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsItemHandler.java index 5bc7e5a56c..709381fd10 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsItemHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsItemHandler.java @@ -15,10 +15,18 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JExpression; -import com.sun.codemodel.JFieldRef; -import com.sun.codemodel.JInvocation; +import static com.sun.codemodel.JExpr.TRUE; +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.TypeKind; +import javax.lang.model.type.TypeMirror; + import org.androidannotations.annotations.OptionsItem; import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.IdAnnotationHelper; @@ -26,19 +34,13 @@ import org.androidannotations.holder.HasOptionsMenu; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.rclass.IRClass; import org.androidannotations.process.IsValid; +import org.androidannotations.rclass.IRClass; -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 java.util.List; - -import static com.sun.codemodel.JExpr.TRUE; -import static com.sun.codemodel.JExpr.invoke; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JFieldRef; +import com.sun.codemodel.JInvocation; public class OptionsItemHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuHandler.java index c0521073fa..da00333f47 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuHandler.java @@ -15,9 +15,11 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JFieldRef; -import com.sun.codemodel.JVar; +import java.util.List; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + import org.androidannotations.annotations.OptionsMenu; import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.IdAnnotationHelper; @@ -25,12 +27,12 @@ import org.androidannotations.holder.HasOptionsMenu; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.rclass.IRClass; import org.androidannotations.process.IsValid; +import org.androidannotations.rclass.IRClass; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import java.util.List; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JFieldRef; +import com.sun.codemodel.JVar; public class OptionsMenuHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuItemHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuItemHandler.java index 1acaf62f75..083e786f81 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuItemHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuItemHandler.java @@ -15,9 +15,11 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JFieldRef; -import com.sun.codemodel.JVar; +import static com.sun.codemodel.JExpr.ref; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + import org.androidannotations.annotations.OptionsMenuItem; import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.IdAnnotationHelper; @@ -25,13 +27,12 @@ import org.androidannotations.holder.HasOptionsMenu; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.rclass.IRClass; import org.androidannotations.process.IsValid; +import org.androidannotations.rclass.IRClass; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; - -import static com.sun.codemodel.JExpr.ref; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JFieldRef; +import com.sun.codemodel.JVar; public class OptionsMenuItemHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java index df093a9c27..0340ba8a33 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java @@ -15,18 +15,24 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; +import static com.sun.codemodel.JExpr.ref; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.type.TypeMirror; + import org.androidannotations.annotations.OrmLiteDao; import org.androidannotations.helper.TargetAnnotationHelper; import org.androidannotations.holder.EComponentHolder; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.IsValid; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.type.TypeMirror; - -import static com.sun.codemodel.JExpr.ref; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JCatchBlock; +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JFieldVar; +import com.sun.codemodel.JTryBlock; +import com.sun.codemodel.JVar; public class OrmLiteDaoHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java index 5223d84f56..94fafc5729 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java @@ -15,14 +15,9 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JFieldRef; -import org.androidannotations.annotations.sharedpreferences.Pref; -import org.androidannotations.annotations.sharedpreferences.SharedPref; -import org.androidannotations.holder.EComponentHolder; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.process.IsValid; +import static org.androidannotations.helper.ModelConstants.GENERATION_SUFFIX; + +import java.util.Set; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; @@ -30,9 +25,16 @@ import javax.lang.model.type.ErrorType; import javax.lang.model.type.TypeKind; import javax.lang.model.type.TypeMirror; -import java.util.Set; -import static org.androidannotations.helper.ModelConstants.GENERATION_SUFFIX; +import org.androidannotations.annotations.sharedpreferences.Pref; +import org.androidannotations.annotations.sharedpreferences.SharedPref; +import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.IsValid; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JFieldRef; public class PrefHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ProduceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ProduceHandler.java index 33276a3d2d..20edbfe093 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ProduceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ProduceHandler.java @@ -15,7 +15,12 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JMethod; +import static org.androidannotations.helper.CanonicalNameConstants.PRODUCE; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; + import org.androidannotations.helper.APTCodeModelHelper; import org.androidannotations.helper.CanonicalNameConstants; import org.androidannotations.helper.TargetAnnotationHelper; @@ -23,11 +28,7 @@ import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.IsValid; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; - -import static org.androidannotations.helper.CanonicalNameConstants.PRODUCE; +import com.sun.codemodel.JMethod; public class ProduceHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java index d8346f165d..0a9c335a11 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java @@ -15,8 +15,13 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JFieldRef; +import static com.sun.codemodel.JExpr.invoke; +import static com.sun.codemodel.JExpr.ref; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.type.TypeMirror; + import org.androidannotations.annotations.res.HtmlRes; import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.CanonicalNameConstants; @@ -26,16 +31,12 @@ import org.androidannotations.model.AndroidRes; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.IsValid; import org.androidannotations.process.ProcessHolder; import org.androidannotations.rclass.IRClass; -import org.androidannotations.process.IsValid; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.type.TypeMirror; -import static com.sun.codemodel.JExpr.invoke; -import static com.sun.codemodel.JExpr.ref; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JFieldRef; public class ResHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java index 0ded2171c2..3275b4ad71 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java @@ -15,24 +15,37 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; -import org.androidannotations.annotations.RoboGuice; -import org.androidannotations.holder.EActivityHolder; -import org.androidannotations.holder.RoboGuiceHolder; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.process.ProcessHolder; -import org.androidannotations.process.IsValid; +import static com.sun.codemodel.JExpr._new; +import static com.sun.codemodel.JExpr._super; +import static com.sun.codemodel.JExpr._this; +import static com.sun.codemodel.JExpr.invoke; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.AnnotationMirror; import javax.lang.model.element.AnnotationValue; import javax.lang.model.element.Element; import javax.lang.model.element.ExecutableElement; -import java.util.ArrayList; -import java.util.List; -import java.util.Map; -import static com.sun.codemodel.JExpr.*; +import org.androidannotations.annotations.RoboGuice; +import org.androidannotations.holder.EActivityHolder; +import org.androidannotations.holder.RoboGuiceHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.IsValid; +import org.androidannotations.process.ProcessHolder; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JFieldVar; +import com.sun.codemodel.JInvocation; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JMod; +import com.sun.codemodel.JTryBlock; +import com.sun.codemodel.JVar; public class RoboGuiceHandler extends BaseAnnotationHandler { @@ -62,7 +75,6 @@ public void process(Element element, EActivityHolder holder) { JMethod getInjector = roboGuiceHolder.getGetInjector(); listenerFields(element, holder); - beforeCreateMethod(holder, scope, eventManager, getInjector); afterSetContentView(holder, scope, eventManager); onRestartMethod(roboGuiceHolder, scope, eventManager); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java index 038c5cafb5..f83acdc7b0 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java @@ -15,21 +15,22 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JExpression; +import static com.sun.codemodel.JExpr.cast; +import static com.sun.codemodel.JExpr.ref; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.type.TypeMirror; + import org.androidannotations.annotations.RootContext; import org.androidannotations.helper.CanonicalNameConstants; import org.androidannotations.holder.EBeanHolder; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.IsValid; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.type.TypeMirror; - -import static com.sun.codemodel.JExpr.cast; -import static com.sun.codemodel.JExpr.ref; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JExpression; public class RootContextHanlder extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarProgressChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarProgressChangeHandler.java index 812e5958f4..44b9b47ba5 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarProgressChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarProgressChangeHandler.java @@ -15,7 +15,15 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; +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.SeekBarProgressChange; import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.CanonicalNameConstants; @@ -25,16 +33,14 @@ import org.androidannotations.holder.OnSeekBarChangeListenerHolder; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.rclass.IRClass; import org.androidannotations.process.IsValid; +import org.androidannotations.rclass.IRClass; -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 java.util.List; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JFieldRef; +import com.sun.codemodel.JInvocation; +import com.sun.codemodel.JVar; public class SeekBarProgressChangeHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarTouchStartHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarTouchStartHandler.java index a2a04bce43..392fbc9508 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarTouchStartHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarTouchStartHandler.java @@ -15,12 +15,13 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JVar; +import javax.annotation.processing.ProcessingEnvironment; + import org.androidannotations.annotations.SeekBarTouchStart; import org.androidannotations.holder.OnSeekBarChangeListenerHolder; -import javax.annotation.processing.ProcessingEnvironment; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JVar; public class SeekBarTouchStartHandler extends AbstractSeekBarTouchHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarTouchStopHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarTouchStopHandler.java index 444018ce2d..791967f411 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarTouchStopHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarTouchStopHandler.java @@ -15,12 +15,13 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JVar; +import javax.annotation.processing.ProcessingEnvironment; + import org.androidannotations.annotations.SeekBarTouchStop; import org.androidannotations.holder.OnSeekBarChangeListenerHolder; -import javax.annotation.processing.ProcessingEnvironment; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JVar; public class SeekBarTouchStopHandler extends AbstractSeekBarTouchHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SharedPrefHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SharedPrefHandler.java index f8754955d9..7df810bd30 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SharedPrefHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SharedPrefHandler.java @@ -15,31 +15,59 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; -import org.androidannotations.annotations.sharedpreferences.*; -import org.androidannotations.api.sharedpreferences.*; +import static com.sun.codemodel.JExpr.invoke; +import static com.sun.codemodel.JExpr.lit; +import static com.sun.codemodel.JMod.PRIVATE; +import static com.sun.codemodel.JMod.STATIC; + +import java.util.ArrayList; +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.TypeElement; +import javax.lang.model.util.ElementFilter; + +import org.androidannotations.annotations.sharedpreferences.DefaultBoolean; +import org.androidannotations.annotations.sharedpreferences.DefaultFloat; +import org.androidannotations.annotations.sharedpreferences.DefaultInt; +import org.androidannotations.annotations.sharedpreferences.DefaultLong; +import org.androidannotations.annotations.sharedpreferences.DefaultRes; +import org.androidannotations.annotations.sharedpreferences.DefaultString; +import org.androidannotations.annotations.sharedpreferences.SharedPref; +import org.androidannotations.api.sharedpreferences.AbstractPrefEditorField; +import org.androidannotations.api.sharedpreferences.AbstractPrefField; +import org.androidannotations.api.sharedpreferences.BooleanPrefEditorField; +import org.androidannotations.api.sharedpreferences.BooleanPrefField; +import org.androidannotations.api.sharedpreferences.EditorHelper; +import org.androidannotations.api.sharedpreferences.FloatPrefEditorField; +import org.androidannotations.api.sharedpreferences.FloatPrefField; +import org.androidannotations.api.sharedpreferences.IntPrefEditorField; +import org.androidannotations.api.sharedpreferences.IntPrefField; +import org.androidannotations.api.sharedpreferences.LongPrefEditorField; +import org.androidannotations.api.sharedpreferences.LongPrefField; +import org.androidannotations.api.sharedpreferences.SharedPreferencesCompat; +import org.androidannotations.api.sharedpreferences.SharedPreferencesHelper; +import org.androidannotations.api.sharedpreferences.StringPrefEditorField; +import org.androidannotations.api.sharedpreferences.StringPrefField; import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.CanonicalNameConstants; import org.androidannotations.helper.IdAnnotationHelper; import org.androidannotations.holder.SharedPrefHolder; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.IsValid; import org.androidannotations.process.ProcessHolder; import org.androidannotations.rclass.IRClass; -import org.androidannotations.process.IsValid; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.TypeElement; -import javax.lang.model.util.ElementFilter; -import java.util.ArrayList; -import java.util.List; -import static com.sun.codemodel.JExpr.invoke; -import static com.sun.codemodel.JExpr.lit; -import static com.sun.codemodel.JMod.PRIVATE; -import static com.sun.codemodel.JMod.STATIC; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JFieldRef; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JVar; public class SharedPrefHandler extends BaseAnnotationHandler implements GeneratingAnnotationHandler { @@ -117,37 +145,37 @@ private void generateConstructor(Element element, SharedPrefHolder holder) { JVar contextParam = holder.getConstructorContextParam(); switch (scope) { - case ACTIVITY_DEFAULT: { - JMethod getLocalClassName = getLocalClassName(holder); - constructorSuperBlock.invoke("super") // - .arg(contextParam.invoke("getSharedPreferences") // - .arg(invoke(getLocalClassName).arg(contextParam)) // - .arg(JExpr.lit(mode))); - break; - } - case ACTIVITY: { - JMethod getLocalClassName = getLocalClassName(holder); - constructorSuperBlock.invoke("super") // - .arg(contextParam.invoke("getSharedPreferences") // - .arg(invoke(getLocalClassName).arg(contextParam) // - .plus(JExpr.lit("_" + interfaceSimpleName))) // - .arg(JExpr.lit(mode))); - break; - } - case UNIQUE: { - constructorSuperBlock.invoke("super") // - .arg(contextParam.invoke("getSharedPreferences") // - .arg(JExpr.lit(interfaceSimpleName)) // - .arg(JExpr.lit(mode))); - break; - } - case APPLICATION_DEFAULT: { - JClass preferenceManagerClass = holder.refClass("android.preference.PreferenceManager"); - constructorSuperBlock.invoke("super") // - .arg(preferenceManagerClass.staticInvoke("getDefaultSharedPreferences") // - .arg(contextParam)); - break; - } + case ACTIVITY_DEFAULT: { + JMethod getLocalClassName = getLocalClassName(holder); + constructorSuperBlock.invoke("super") // + .arg(contextParam.invoke("getSharedPreferences") // + .arg(invoke(getLocalClassName).arg(contextParam)) // + .arg(JExpr.lit(mode))); + break; + } + case ACTIVITY: { + JMethod getLocalClassName = getLocalClassName(holder); + constructorSuperBlock.invoke("super") // + .arg(contextParam.invoke("getSharedPreferences") // + .arg(invoke(getLocalClassName).arg(contextParam) // + .plus(JExpr.lit("_" + interfaceSimpleName))) // + .arg(JExpr.lit(mode))); + break; + } + case UNIQUE: { + constructorSuperBlock.invoke("super") // + .arg(contextParam.invoke("getSharedPreferences") // + .arg(JExpr.lit(interfaceSimpleName)) // + .arg(JExpr.lit(mode))); + break; + } + case APPLICATION_DEFAULT: { + JClass preferenceManagerClass = holder.refClass("android.preference.PreferenceManager"); + constructorSuperBlock.invoke("super") // + .arg(preferenceManagerClass.staticInvoke("getDefaultSharedPreferences") // + .arg(contextParam)); + break; + } } } @@ -179,7 +207,7 @@ private JMethod getLocalClassName(SharedPrefHolder holder) { } private void generateFieldMethodAndEditorFieldMethod(Element element, SharedPrefHolder sharedPrefHolder) { - for(ExecutableElement method : getValidMethods(element)) { + for (ExecutableElement method : getValidMethods(element)) { generateFieldMethod(sharedPrefHolder, method); sharedPrefHolder.createEditorFieldMethods(method); } @@ -235,7 +263,7 @@ private void createFieldMethod(SharedPrefHolder holder, ExecutableElement method JExpression defaultValue = defaultAnnotationValue; if (defaultAnnotationValue == null) { if (method.getAnnotation(DefaultRes.class) != null) { - defaultValue = extractResValue(holder, method,res); + defaultValue = extractResValue(holder, method, res); } else { defaultValue = defValue; } @@ -249,17 +277,17 @@ private JExpression extractResValue(SharedPrefHolder holder, Element method, IRC String resourceGetMethodName = null; switch (res) { - case BOOL: - resourceGetMethodName = "getBoolean"; - break; - case INTEGER: - resourceGetMethodName = "getInteger"; - break; - case STRING: - resourceGetMethodName = "getString"; - break; - default: - break; + case BOOL: + resourceGetMethodName = "getBoolean"; + break; + case INTEGER: + resourceGetMethodName = "getInteger"; + break; + case STRING: + resourceGetMethodName = "getString"; + break; + default: + break; } return holder.getContextField().invoke("getResources").invoke(resourceGetMethodName).arg(idRef); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SubscribeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SubscribeHandler.java index 75a2a3ebc4..bb4cb13618 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SubscribeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SubscribeHandler.java @@ -15,7 +15,12 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JMethod; +import static org.androidannotations.helper.CanonicalNameConstants.SUBSCRIBE; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; + import org.androidannotations.helper.APTCodeModelHelper; import org.androidannotations.helper.CanonicalNameConstants; import org.androidannotations.helper.TargetAnnotationHelper; @@ -23,11 +28,7 @@ import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.IsValid; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; - -import static org.androidannotations.helper.CanonicalNameConstants.SUBSCRIBE; +import com.sun.codemodel.JMethod; public class SubscribeHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java index 1708ff9030..6590802a4d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java @@ -15,19 +15,20 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JFieldRef; -import org.androidannotations.annotations.SystemService; -import org.androidannotations.holder.EComponentHolder; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.process.IsValid; +import static com.sun.codemodel.JExpr.cast; +import static com.sun.codemodel.JExpr.ref; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; import javax.lang.model.type.TypeMirror; -import static com.sun.codemodel.JExpr.cast; -import static com.sun.codemodel.JExpr.ref; +import org.androidannotations.annotations.SystemService; +import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.IsValid; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JFieldRef; public class SystemServiceHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TextChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TextChangeHandler.java index 04db41eaf4..1c0d93a33b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TextChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TextChangeHandler.java @@ -15,7 +15,15 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; +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.TextChange; import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.CanonicalNameConstants; @@ -25,16 +33,14 @@ import org.androidannotations.holder.TextWatcherHolder; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.rclass.IRClass; import org.androidannotations.process.IsValid; +import org.androidannotations.rclass.IRClass; -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 java.util.List; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JFieldRef; +import com.sun.codemodel.JInvocation; +import com.sun.codemodel.JVar; public class TextChangeHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TouchHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TouchHandler.java index ee952ab8ed..5b7b9ca010 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TouchHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TouchHandler.java @@ -15,10 +15,7 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; -import org.androidannotations.annotations.Touch; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.process.IsValid; +import java.util.List; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; @@ -26,7 +23,19 @@ import javax.lang.model.element.VariableElement; import javax.lang.model.type.TypeKind; import javax.lang.model.type.TypeMirror; -import java.util.List; + +import org.androidannotations.annotations.Touch; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.IsValid; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JDefinedClass; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JInvocation; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JMod; +import com.sun.codemodel.JVar; public class TouchHandler extends AbstractListenerHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TraceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TraceHandler.java index eaad3f5a7f..76632286b2 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TraceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TraceHandler.java @@ -15,19 +15,34 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; +import static org.androidannotations.helper.AndroidConstants.LOG_DEBUG; +import static org.androidannotations.helper.AndroidConstants.LOG_ERROR; +import static org.androidannotations.helper.AndroidConstants.LOG_INFO; +import static org.androidannotations.helper.AndroidConstants.LOG_VERBOSE; +import static org.androidannotations.helper.AndroidConstants.LOG_WARN; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; + import org.androidannotations.annotations.Trace; import org.androidannotations.helper.APTCodeModelHelper; import org.androidannotations.holder.EComponentHolder; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.process.ProcessHolder; import org.androidannotations.process.IsValid; +import org.androidannotations.process.ProcessHolder; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; - -import static org.androidannotations.helper.AndroidConstants.*; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JCodeModel; +import com.sun.codemodel.JConditional; +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.JTryBlock; +import com.sun.codemodel.JVar; public class TraceHandler extends BaseAnnotationHandler { @@ -107,35 +122,35 @@ public void process(Element element, EComponentHolder holder) throws Exception { private String logMethodNameFromLevel(int level) { switch (level) { - case LOG_DEBUG: - return "d"; - case LOG_VERBOSE: - return "v"; - case LOG_INFO: - return "i"; - case LOG_WARN: - return "w"; - case LOG_ERROR: - return "e"; - default: - throw new IllegalArgumentException("Unrecognized Log level : " + level); + case LOG_DEBUG: + return "d"; + case LOG_VERBOSE: + return "v"; + case LOG_INFO: + return "i"; + case LOG_WARN: + return "w"; + case LOG_ERROR: + return "e"; + default: + throw new IllegalArgumentException("Unrecognized Log level : " + level); } } private JFieldRef logLevelFromInt(int level, JClass logClass) { switch (level) { - case LOG_DEBUG: - return logClass.staticRef("DEBUG"); - case LOG_VERBOSE: - return logClass.staticRef("VERBOSE"); - case LOG_INFO: - return logClass.staticRef("INFO"); - case LOG_WARN: - return logClass.staticRef("WARN"); - case LOG_ERROR: - return logClass.staticRef("ERROR"); - default: - throw new IllegalArgumentException("Unrecognized log level. Given value:" + level); + case LOG_DEBUG: + return logClass.staticRef("DEBUG"); + case LOG_VERBOSE: + return logClass.staticRef("VERBOSE"); + case LOG_INFO: + return logClass.staticRef("INFO"); + case LOG_WARN: + return logClass.staticRef("WARN"); + case LOG_ERROR: + return logClass.staticRef("ERROR"); + default: + throw new IllegalArgumentException("Unrecognized log level. Given value:" + level); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TransactionalHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TransactionalHandler.java index 6ac4df6d03..0ecab9b9c0 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TransactionalHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TransactionalHandler.java @@ -15,16 +15,25 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; + import org.androidannotations.annotations.Transactional; import org.androidannotations.helper.APTCodeModelHelper; import org.androidannotations.holder.EComponentHolder; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.IsValid; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JCatchBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JInvocation; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JTryBlock; +import com.sun.codemodel.JVar; public class TransactionalHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/UiThreadHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/UiThreadHandler.java index c7a0d04b9e..dbf98b0411 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/UiThreadHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/UiThreadHandler.java @@ -15,17 +15,19 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.*; -import org.androidannotations.annotations.UiThread; -import org.androidannotations.helper.APTCodeModelHelper; -import org.androidannotations.holder.EComponentHolder; +import static com.sun.codemodel.JExpr._new; +import static com.sun.codemodel.JExpr.lit; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; import javax.lang.model.element.ExecutableElement; -import static com.sun.codemodel.JExpr._new; -import static com.sun.codemodel.JExpr.lit; +import org.androidannotations.annotations.UiThread; +import org.androidannotations.helper.APTCodeModelHelper; +import org.androidannotations.holder.EComponentHolder; + +import com.sun.codemodel.JDefinedClass; +import com.sun.codemodel.JMethod; public class UiThreadHandler extends AbstractRunnableHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java index f31bef595a..1fc3efbb5d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java @@ -15,8 +15,13 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JFieldRef; +import static com.sun.codemodel.JExpr.cast; +import static com.sun.codemodel.JExpr.ref; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.type.TypeMirror; + import org.androidannotations.annotations.ViewById; import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.IdAnnotationHelper; @@ -24,15 +29,11 @@ import org.androidannotations.holder.EComponentWithViewSupportHolder; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; -import org.androidannotations.rclass.IRClass; import org.androidannotations.process.IsValid; +import org.androidannotations.rclass.IRClass; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.type.TypeMirror; - -import static com.sun.codemodel.JExpr.cast; -import static com.sun.codemodel.JExpr.ref; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JFieldRef; public class ViewByIdHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/WindowFeatureHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/WindowFeatureHandler.java index 1c88e42cb5..42979d48ba 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/WindowFeatureHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/WindowFeatureHandler.java @@ -15,14 +15,15 @@ */ package org.androidannotations.handler; -import com.sun.codemodel.JExpr; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + import org.androidannotations.annotations.WindowFeature; import org.androidannotations.holder.EActivityHolder; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.IsValid; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; +import com.sun.codemodel.JExpr; public class WindowFeatureHandler extends BaseAnnotationHandler { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java index bbddc1cf62..b24f424aee 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java @@ -15,10 +15,9 @@ */ package org.androidannotations.helper; -import com.sun.codemodel.*; -import org.androidannotations.holder.EComponentHolder; -import org.androidannotations.holder.GeneratedClassHolder; -import org.androidannotations.process.ProcessHolder; +import java.lang.reflect.Field; +import java.util.ArrayList; +import java.util.List; import javax.lang.model.element.ExecutableElement; import javax.lang.model.element.VariableElement; @@ -26,9 +25,26 @@ import javax.lang.model.type.DeclaredType; import javax.lang.model.type.TypeMirror; import javax.lang.model.type.WildcardType; -import java.lang.reflect.Field; -import java.util.ArrayList; -import java.util.List; + +import org.androidannotations.holder.EComponentHolder; +import org.androidannotations.holder.GeneratedClassHolder; +import org.androidannotations.process.ProcessHolder; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JCatchBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JCodeModel; +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.JStatement; +import com.sun.codemodel.JTryBlock; +import com.sun.codemodel.JType; +import com.sun.codemodel.JVar; public class APTCodeModelHelper { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ActionBarSherlockHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ActionBarSherlockHelper.java index 1adc976fef..251a4f2843 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ActionBarSherlockHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ActionBarSherlockHelper.java @@ -15,13 +15,13 @@ */ package org.androidannotations.helper; -import org.androidannotations.holder.EComponentHolder; - import javax.lang.model.element.TypeElement; import javax.lang.model.type.DeclaredType; import javax.lang.model.type.NoType; import javax.lang.model.type.TypeMirror; +import org.androidannotations.holder.EComponentHolder; + public class ActionBarSherlockHelper { private final AnnotationHelper annotationHelper; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ActivityIntentBuilder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ActivityIntentBuilder.java index bc37efb866..541479c861 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ActivityIntentBuilder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ActivityIntentBuilder.java @@ -15,10 +15,17 @@ */ package org.androidannotations.helper; -import com.sun.codemodel.*; +import static com.sun.codemodel.JMod.PUBLIC; + import org.androidannotations.holder.HasIntentBuilder; -import static com.sun.codemodel.JMod.PUBLIC; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JClassAlreadyExistsException; +import com.sun.codemodel.JConditional; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JVar; public class ActivityIntentBuilder extends IntentBuilder { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AndroidManifestFinder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AndroidManifestFinder.java index ad20349ec9..e89e9bd6f2 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AndroidManifestFinder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AndroidManifestFinder.java @@ -15,10 +15,14 @@ */ package org.androidannotations.helper; -import org.w3c.dom.Document; -import org.w3c.dom.Element; -import org.w3c.dom.Node; -import org.w3c.dom.NodeList; +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.net.URI; +import java.net.URISyntaxException; +import java.util.ArrayList; +import java.util.List; +import java.util.Properties; import javax.annotation.processing.Filer; import javax.annotation.processing.Messager; @@ -28,14 +32,11 @@ import javax.tools.JavaFileObject; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; -import java.io.File; -import java.io.FileInputStream; -import java.io.IOException; -import java.net.URI; -import java.net.URISyntaxException; -import java.util.ArrayList; -import java.util.List; -import java.util.Properties; + +import org.w3c.dom.Document; +import org.w3c.dom.Element; +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; public class AndroidManifestFinder { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AnnotationHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AnnotationHelper.java index d647aa1352..52dee18af3 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AnnotationHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AnnotationHelper.java @@ -15,30 +15,38 @@ */ package org.androidannotations.helper; -import com.sun.codemodel.JFieldRef; -import org.androidannotations.annotations.OnActivityResult; -import org.androidannotations.annotations.OptionsItem; -import org.androidannotations.annotations.ResId; -import org.androidannotations.holder.GeneratedClassHolder; -import org.androidannotations.rclass.IRInnerClass; -import org.androidannotations.rclass.RInnerClass; +import static org.androidannotations.helper.ModelConstants.VALID_ENHANCED_COMPONENT_ANNOTATIONS; + +import java.lang.annotation.Annotation; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.*; +import javax.lang.model.element.AnnotationMirror; +import javax.lang.model.element.AnnotationValue; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.Modifier; +import javax.lang.model.element.NestingKind; +import javax.lang.model.element.TypeElement; import javax.lang.model.type.DeclaredType; import javax.lang.model.type.MirroredTypeException; import javax.lang.model.type.TypeMirror; import javax.lang.model.util.Elements; import javax.lang.model.util.Types; import javax.tools.Diagnostic; -import java.lang.annotation.Annotation; -import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Method; -import java.util.ArrayList; -import java.util.List; -import java.util.Map; -import static org.androidannotations.helper.ModelConstants.VALID_ENHANCED_COMPONENT_ANNOTATIONS; +import org.androidannotations.annotations.OnActivityResult; +import org.androidannotations.annotations.OptionsItem; +import org.androidannotations.annotations.ResId; +import org.androidannotations.holder.GeneratedClassHolder; +import org.androidannotations.rclass.IRInnerClass; +import org.androidannotations.rclass.RInnerClass; + +import com.sun.codemodel.JFieldRef; public class AnnotationHelper { @@ -141,21 +149,21 @@ public Types getTypeUtils() { return processingEnv.getTypeUtils(); } - /** - * Returns a list of {@link JFieldRef} linking to the R class, based on the - * given annotation - * - * @see #extractAnnotationResources(Element, String, IRInnerClass, boolean) - */ - public List extractAnnotationFieldRefs(GeneratedClassHolder holder, Element element, String annotationName, IRInnerClass rInnerClass, boolean useElementName) { - List fieldRefs = new ArrayList(); + /** + * Returns a list of {@link JFieldRef} linking to the R class, based on the + * given annotation + * + * @see #extractAnnotationResources(Element, String, IRInnerClass, boolean) + */ + public List extractAnnotationFieldRefs(GeneratedClassHolder holder, Element element, String annotationName, IRInnerClass rInnerClass, boolean useElementName) { + List fieldRefs = new ArrayList(); - for (String refQualifiedName : extractAnnotationResources(element, annotationName, rInnerClass, useElementName)) { - fieldRefs.add(RInnerClass.extractIdStaticRef(holder, refQualifiedName)); - } + for (String refQualifiedName : extractAnnotationResources(element, annotationName, rInnerClass, useElementName)) { + fieldRefs.add(RInnerClass.extractIdStaticRef(holder, refQualifiedName)); + } - return fieldRefs; - } + return fieldRefs; + } /** * Method to handle all annotations dealing with resource ids that can be diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/BundleHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/BundleHelper.java index 40ca3e397e..e91460fb90 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/BundleHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/BundleHelper.java @@ -15,17 +15,20 @@ */ package org.androidannotations.helper; +import static org.androidannotations.helper.CanonicalNameConstants.BUNDLE; +import static org.androidannotations.helper.CanonicalNameConstants.CHAR_SEQUENCE; +import static org.androidannotations.helper.CanonicalNameConstants.STRING; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + import javax.lang.model.element.Element; import javax.lang.model.element.TypeElement; import javax.lang.model.type.ArrayType; import javax.lang.model.type.DeclaredType; import javax.lang.model.type.TypeKind; import javax.lang.model.type.TypeMirror; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -import static org.androidannotations.helper.CanonicalNameConstants.*; public class BundleHelper { public static final Map methodSuffixNameByTypeName = new HashMap(); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/GreenDroidHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/GreenDroidHelper.java index a61867f304..28dddbffde 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/GreenDroidHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/GreenDroidHelper.java @@ -15,12 +15,13 @@ */ package org.androidannotations.helper; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.TypeElement; import java.util.ArrayList; import java.util.Arrays; import java.util.List; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.TypeElement; + public class GreenDroidHelper { public static final String GREENDROID_GD_ACTIVITY_CLASS = "greendroid.app.GDActivity"; @@ -31,12 +32,12 @@ public class GreenDroidHelper { public static final String GREENDROID_GD_MAP_ACTIVITY_CLASS = "greendroid.app.GDMapActivity"; - public static final List GREENDROID_ACTIVITIES_LIST_CLASS = Arrays.asList(new String[]{ // + public static final List GREENDROID_ACTIVITIES_LIST_CLASS = Arrays.asList(new String[] { // GREENDROID_GD_ACTIVITY_CLASS, // - GREENDROID_GD_LIST_ACTIVITY_CLASS, // - GREENDROID_GD_TAB_ACTIVITY_CLASS, // - GREENDROID_GD_MAP_ACTIVITY_CLASS // - }); + GREENDROID_GD_LIST_ACTIVITY_CLASS, // + GREENDROID_GD_TAB_ACTIVITY_CLASS, // + GREENDROID_GD_MAP_ACTIVITY_CLASS // + }); private ProcessingEnvironment processingEnv; private List greendroidActivityElements; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/HoloEverywhereHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/HoloEverywhereHelper.java index 3552a36dec..7a91ab8080 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/HoloEverywhereHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/HoloEverywhereHelper.java @@ -15,13 +15,13 @@ */ package org.androidannotations.helper; -import org.androidannotations.holder.EComponentHolder; - import javax.lang.model.element.TypeElement; import javax.lang.model.type.DeclaredType; import javax.lang.model.type.NoType; import javax.lang.model.type.TypeMirror; +import org.androidannotations.holder.EComponentHolder; + public class HoloEverywhereHelper { private EComponentHolder holder; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdAnnotationHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdAnnotationHelper.java index ec5c70d8e0..c223dc56ba 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdAnnotationHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdAnnotationHelper.java @@ -15,15 +15,17 @@ */ package org.androidannotations.helper; -import com.sun.codemodel.JFieldRef; +import java.util.List; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + import org.androidannotations.holder.GeneratedClassHolder; import org.androidannotations.rclass.IRClass; import org.androidannotations.rclass.IRClass.Res; import org.androidannotations.rclass.IRInnerClass; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import java.util.List; +import com.sun.codemodel.JFieldRef; public class IdAnnotationHelper extends TargetAnnotationHelper { @@ -48,21 +50,21 @@ public List extractAnnotationResources(Element element, Res res, boolean return super.extractAnnotationResources(element, getTarget(), rClass.get(res), useElementName); } - public List extractAnnotationFieldRefs(GeneratedClassHolder holder, Element element, Res res, boolean useElementName) { - return super.extractAnnotationFieldRefs(holder, element, getTarget(), rClass.get(res), useElementName); - } + public List extractAnnotationFieldRefs(GeneratedClassHolder holder, Element element, Res res, boolean useElementName) { + return super.extractAnnotationFieldRefs(holder, element, getTarget(), rClass.get(res), useElementName); + } - public JFieldRef extractOneAnnotationFieldRef(GeneratedClassHolder holder, Element element, Res res, boolean useElementName) { - return extractOneAnnotationFieldRef(holder, element, getTarget(), res, useElementName); - } + public JFieldRef extractOneAnnotationFieldRef(GeneratedClassHolder holder, Element element, Res res, boolean useElementName) { + return extractOneAnnotationFieldRef(holder, element, getTarget(), res, useElementName); + } - public JFieldRef extractOneAnnotationFieldRef(GeneratedClassHolder holder, Element element, String annotationName, Res res, boolean useElementName) { - List jFieldRefs = extractAnnotationFieldRefs(holder, element, annotationName, rClass.get(res), useElementName); + public JFieldRef extractOneAnnotationFieldRef(GeneratedClassHolder holder, Element element, String annotationName, Res res, boolean useElementName) { + List jFieldRefs = extractAnnotationFieldRefs(holder, element, annotationName, rClass.get(res), useElementName); - if (jFieldRefs.size() == 1) { - return jFieldRefs.get(0); - } else { - return null; - } - } + if (jFieldRefs.size() == 1) { + return jFieldRefs.get(0); + } else { + return null; + } + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdValidatorHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdValidatorHelper.java index d1c2ab10cb..e812b9725b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdValidatorHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdValidatorHelper.java @@ -15,15 +15,16 @@ */ package org.androidannotations.helper; +import java.util.List; +import java.util.Set; + +import javax.lang.model.element.Element; + import org.androidannotations.annotations.ResId; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.IsValid; import org.androidannotations.rclass.IRClass.Res; -import javax.lang.model.element.Element; -import java.util.List; -import java.util.Set; - public class IdValidatorHelper extends ValidatorHelper { private final IdAnnotationHelper idAnnotationHelper; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IntentBuilder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IntentBuilder.java index ea0372f0a2..e679c7bb08 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IntentBuilder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IntentBuilder.java @@ -15,12 +15,22 @@ */ package org.androidannotations.helper; -import com.sun.codemodel.*; -import org.androidannotations.holder.HasIntentBuilder; - import static com.sun.codemodel.JExpr._new; import static com.sun.codemodel.JExpr._this; -import static com.sun.codemodel.JMod.*; +import static com.sun.codemodel.JMod.FINAL; +import static com.sun.codemodel.JMod.PRIVATE; +import static com.sun.codemodel.JMod.PUBLIC; +import static com.sun.codemodel.JMod.STATIC; + +import org.androidannotations.holder.HasIntentBuilder; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JClassAlreadyExistsException; +import com.sun.codemodel.JFieldVar; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JMod; +import com.sun.codemodel.JVar; public class IntentBuilder { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/RestAnnotationHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/RestAnnotationHelper.java index 94b1eb2782..1c74a4b125 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/RestAnnotationHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/RestAnnotationHelper.java @@ -15,17 +15,43 @@ */ package org.androidannotations.helper; -import com.sun.codemodel.*; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.TreeMap; +import java.util.TreeSet; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ElementKind; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.ArrayType; +import javax.lang.model.type.DeclaredType; +import javax.lang.model.type.TypeKind; +import javax.lang.model.type.TypeMirror; +import javax.lang.model.type.WildcardType; + import org.androidannotations.annotations.rest.Accept; import org.androidannotations.holder.RestHolder; import org.androidannotations.process.IsValid; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.*; -import javax.lang.model.type.*; -import java.util.*; -import java.util.regex.Matcher; -import java.util.regex.Pattern; +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.JType; +import com.sun.codemodel.JVar; public class RestAnnotationHelper extends TargetAnnotationHelper { @@ -227,7 +253,7 @@ public JClass retrieveResponseClass(TypeMirror returnType, RestHolder holder) { *
  • Return {@link Object} definition
    • * * - * + * */ private JClass resolveResponseClass(TypeMirror expectedType, RestHolder holder) { // is a class or an interface diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ServiceIntentBuilder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ServiceIntentBuilder.java index 70b7e0cc4f..e93ab41009 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ServiceIntentBuilder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ServiceIntentBuilder.java @@ -15,11 +15,12 @@ */ package org.androidannotations.helper; -import com.sun.codemodel.JClassAlreadyExistsException; -import com.sun.codemodel.JMethod; +import static com.sun.codemodel.JMod.PUBLIC; + import org.androidannotations.holder.HasIntentBuilder; -import static com.sun.codemodel.JMod.PUBLIC; +import com.sun.codemodel.JClassAlreadyExistsException; +import com.sun.codemodel.JMethod; public class ServiceIntentBuilder extends IntentBuilder { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/TargetAnnotationHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/TargetAnnotationHelper.java index 3230b213d2..283e007ab5 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/TargetAnnotationHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/TargetAnnotationHelper.java @@ -15,10 +15,11 @@ */ package org.androidannotations.helper; +import java.lang.annotation.Annotation; + import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; import javax.lang.model.type.DeclaredType; -import java.lang.annotation.Annotation; public class TargetAnnotationHelper extends AnnotationHelper { 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 cba3ec69db..38cee3566e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorHelper.java @@ -15,25 +15,63 @@ */ package org.androidannotations.helper; -import org.androidannotations.annotations.*; -import org.androidannotations.annotations.rest.*; -import org.androidannotations.annotations.sharedpreferences.*; -import org.androidannotations.api.sharedpreferences.SharedPreferencesHelper; -import org.androidannotations.model.AndroidSystemServices; -import org.androidannotations.model.AnnotationElements; -import org.androidannotations.process.IsValid; +import static java.util.Arrays.asList; +import static org.androidannotations.helper.AndroidConstants.LOG_DEBUG; +import static org.androidannotations.helper.AndroidConstants.LOG_ERROR; +import static org.androidannotations.helper.AndroidConstants.LOG_INFO; +import static org.androidannotations.helper.AndroidConstants.LOG_VERBOSE; +import static org.androidannotations.helper.AndroidConstants.LOG_WARN; +import static org.androidannotations.helper.CanonicalNameConstants.CLIENT_HTTP_REQUEST_INTERCEPTOR; +import static org.androidannotations.helper.CanonicalNameConstants.HTTP_MESSAGE_CONVERTER; +import static org.androidannotations.helper.CanonicalNameConstants.INTERNET_PERMISSION; +import static org.androidannotations.helper.ModelConstants.GENERATION_SUFFIX; +import static org.androidannotations.helper.ModelConstants.VALID_ENHANCED_COMPONENT_ANNOTATIONS; +import static org.androidannotations.helper.ModelConstants.VALID_ENHANCED_VIEW_SUPPORT_ANNOTATIONS; -import javax.lang.model.element.*; -import javax.lang.model.type.*; +import java.lang.annotation.Annotation; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.List; +import java.util.Set; + +import javax.lang.model.element.AnnotationMirror; +import javax.lang.model.element.Element; +import javax.lang.model.element.ElementKind; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.Modifier; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.ArrayType; +import javax.lang.model.type.DeclaredType; +import javax.lang.model.type.ErrorType; +import javax.lang.model.type.TypeKind; +import javax.lang.model.type.TypeMirror; import javax.lang.model.util.ElementFilter; import javax.lang.model.util.Elements; -import java.lang.annotation.Annotation; -import java.util.*; -import static java.util.Arrays.asList; -import static org.androidannotations.helper.AndroidConstants.*; -import static org.androidannotations.helper.CanonicalNameConstants.*; -import static org.androidannotations.helper.ModelConstants.*; +import org.androidannotations.annotations.EActivity; +import org.androidannotations.annotations.EBean; +import org.androidannotations.annotations.EFragment; +import org.androidannotations.annotations.Trace; +import org.androidannotations.annotations.ViewById; +import org.androidannotations.annotations.rest.Delete; +import org.androidannotations.annotations.rest.Get; +import org.androidannotations.annotations.rest.Head; +import org.androidannotations.annotations.rest.Options; +import org.androidannotations.annotations.rest.Post; +import org.androidannotations.annotations.rest.Put; +import org.androidannotations.annotations.rest.Rest; +import org.androidannotations.annotations.sharedpreferences.DefaultBoolean; +import org.androidannotations.annotations.sharedpreferences.DefaultFloat; +import org.androidannotations.annotations.sharedpreferences.DefaultInt; +import org.androidannotations.annotations.sharedpreferences.DefaultLong; +import org.androidannotations.annotations.sharedpreferences.DefaultString; +import org.androidannotations.annotations.sharedpreferences.SharedPref; +import org.androidannotations.api.sharedpreferences.SharedPreferencesHelper; +import org.androidannotations.model.AndroidSystemServices; +import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.IsValid; public class ValidatorHelper { 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 4e65d54e4b..6f422129aa 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorParameterHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ValidatorParameterHelper.java @@ -15,16 +15,17 @@ */ package org.androidannotations.helper; -import org.androidannotations.process.IsValid; +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 java.util.Arrays; -import java.util.List; -import static java.util.Arrays.asList; +import org.androidannotations.process.IsValid; public class ValidatorParameterHelper { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ViewNotifierHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ViewNotifierHelper.java index ce2067cb86..1bfb503239 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ViewNotifierHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ViewNotifierHelper.java @@ -15,18 +15,21 @@ */ package org.androidannotations.helper; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JFieldVar; -import com.sun.codemodel.JVar; +import static com.sun.codemodel.JExpr._new; +import static com.sun.codemodel.JExpr._null; +import static com.sun.codemodel.JExpr._this; +import static com.sun.codemodel.JMod.FINAL; +import static com.sun.codemodel.JMod.PRIVATE; + import org.androidannotations.api.view.HasViews; import org.androidannotations.api.view.OnViewChangedNotifier; import org.androidannotations.holder.EComponentHolder; import org.androidannotations.holder.EViewHolder; -import static com.sun.codemodel.JExpr.*; -import static com.sun.codemodel.JMod.FINAL; -import static com.sun.codemodel.JMod.PRIVATE; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JFieldVar; +import com.sun.codemodel.JVar; public class ViewNotifierHelper { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/BaseGeneratedClassHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/BaseGeneratedClassHolder.java index 76792dfd4d..4630871e8a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/BaseGeneratedClassHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/BaseGeneratedClassHolder.java @@ -15,79 +15,83 @@ */ package org.androidannotations.holder; -import com.sun.codemodel.*; -import org.androidannotations.helper.ModelConstants; -import org.androidannotations.process.ProcessHolder; +import static com.sun.codemodel.JMod.FINAL; +import static com.sun.codemodel.JMod.PUBLIC; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; import javax.lang.model.element.TypeElement; -import static com.sun.codemodel.JMod.FINAL; -import static com.sun.codemodel.JMod.PUBLIC; +import org.androidannotations.helper.ModelConstants; +import org.androidannotations.process.ProcessHolder; + +import com.sun.codemodel.ClassType; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JCodeModel; +import com.sun.codemodel.JDefinedClass; public abstract class BaseGeneratedClassHolder implements GeneratedClassHolder { - protected final ProcessHolder processHolder; - protected JDefinedClass generatedClass; - protected final TypeElement annotatedElement; - - public BaseGeneratedClassHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { - this.processHolder = processHolder; - this.annotatedElement = annotatedElement; - setGeneratedClass(); - } - - protected void setGeneratedClass() throws Exception { - String annotatedComponentQualifiedName = annotatedElement.getQualifiedName().toString(); - String subComponentQualifiedName = annotatedComponentQualifiedName + ModelConstants.GENERATION_SUFFIX; - JClass annotatedComponent = codeModel().directClass(annotatedComponentQualifiedName); - generatedClass = codeModel()._class(PUBLIC | FINAL, subComponentQualifiedName, ClassType.CLASS); - generatedClass._extends(annotatedComponent); - } - - @Override - public JDefinedClass getGeneratedClass() { - return generatedClass; - } - - @Override - public TypeElement getAnnotatedElement() { - return annotatedElement; - } - - @Override - public ProcessingEnvironment processingEnvironment() { - return processHolder.processingEnvironment(); - } - - @Override - public ProcessHolder.Classes classes() { - return processHolder.classes(); - } - - @Override - public JCodeModel codeModel() { - return processHolder.codeModel(); - } - - @Override - public JClass refClass(String fullyQualifiedClassName) { - return processHolder.refClass(fullyQualifiedClassName); - } - - @Override - public JClass refClass(Class clazz) { - return processHolder.refClass(clazz); - } - - @Override - public JDefinedClass definedClass(String fullyQualifiedClassName) { - return processHolder.definedClass(fullyQualifiedClassName); - } - - @Override - public void generateApiClass(Element originatingElement, Class apiClass) { - processHolder.generateApiClass(originatingElement, apiClass); - } + protected final ProcessHolder processHolder; + protected JDefinedClass generatedClass; + protected final TypeElement annotatedElement; + + public BaseGeneratedClassHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { + this.processHolder = processHolder; + this.annotatedElement = annotatedElement; + setGeneratedClass(); + } + + protected void setGeneratedClass() throws Exception { + String annotatedComponentQualifiedName = annotatedElement.getQualifiedName().toString(); + String subComponentQualifiedName = annotatedComponentQualifiedName + ModelConstants.GENERATION_SUFFIX; + JClass annotatedComponent = codeModel().directClass(annotatedComponentQualifiedName); + generatedClass = codeModel()._class(PUBLIC | FINAL, subComponentQualifiedName, ClassType.CLASS); + generatedClass._extends(annotatedComponent); + } + + @Override + public JDefinedClass getGeneratedClass() { + return generatedClass; + } + + @Override + public TypeElement getAnnotatedElement() { + return annotatedElement; + } + + @Override + public ProcessingEnvironment processingEnvironment() { + return processHolder.processingEnvironment(); + } + + @Override + public ProcessHolder.Classes classes() { + return processHolder.classes(); + } + + @Override + public JCodeModel codeModel() { + return processHolder.codeModel(); + } + + @Override + public JClass refClass(String fullyQualifiedClassName) { + return processHolder.refClass(fullyQualifiedClassName); + } + + @Override + public JClass refClass(Class clazz) { + return processHolder.refClass(clazz); + } + + @Override + public JDefinedClass definedClass(String fullyQualifiedClassName) { + return processHolder.definedClass(fullyQualifiedClassName); + } + + @Override + public void generateApiClass(Element originatingElement, Class apiClass) { + processHolder.generateApiClass(originatingElement, apiClass); + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java index 69a02dcc4a..4fd27c34e0 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java @@ -15,10 +15,19 @@ */ package org.androidannotations.holder; -import com.sun.codemodel.*; -import org.androidannotations.api.SdkVersionHelper; -import org.androidannotations.helper.*; -import org.androidannotations.process.ProcessHolder; +import static com.sun.codemodel.JExpr.FALSE; +import static com.sun.codemodel.JExpr.TRUE; +import static com.sun.codemodel.JExpr._new; +import static com.sun.codemodel.JExpr._null; +import static com.sun.codemodel.JExpr._super; +import static com.sun.codemodel.JExpr._this; +import static com.sun.codemodel.JExpr.cast; +import static com.sun.codemodel.JExpr.invoke; +import static com.sun.codemodel.JMod.PRIVATE; +import static com.sun.codemodel.JMod.PUBLIC; + +import java.util.ArrayList; +import java.util.List; import javax.lang.model.element.Element; import javax.lang.model.element.ExecutableElement; @@ -26,12 +35,27 @@ import javax.lang.model.element.TypeElement; import javax.lang.model.type.TypeKind; import javax.lang.model.util.ElementFilter; -import java.util.ArrayList; -import java.util.List; -import static com.sun.codemodel.JExpr.*; -import static com.sun.codemodel.JMod.PRIVATE; -import static com.sun.codemodel.JMod.PUBLIC; +import org.androidannotations.api.SdkVersionHelper; +import org.androidannotations.helper.ActionBarSherlockHelper; +import org.androidannotations.helper.ActivityIntentBuilder; +import org.androidannotations.helper.AnnotationHelper; +import org.androidannotations.helper.CanonicalNameConstants; +import org.androidannotations.helper.GreenDroidHelper; +import org.androidannotations.process.ProcessHolder; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JClassAlreadyExistsException; +import com.sun.codemodel.JDefinedClass; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JFieldVar; +import com.sun.codemodel.JInvocation; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JMod; +import com.sun.codemodel.JType; +import com.sun.codemodel.JVar; public class EActivityHolder extends EComponentWithViewSupportHolder implements HasIntentBuilder, HasExtras, HasInstanceState, HasOptionsMenu, HasOnActivityResult { @@ -42,7 +66,7 @@ public class EActivityHolder extends EComponentWithViewSupportHolder implements private JVar initSavedInstanceParam; private JDefinedClass intentBuilderClass; private JFieldVar intentField; - private InstanceStateHolder instanceStateHolder; + private InstanceStateHolder instanceStateHolder; private OnActivityResultHolder onActivityResultHolder; private RoboGuiceHolder roboGuiceHolder; private JMethod injectExtrasMethod; @@ -65,7 +89,7 @@ public class EActivityHolder extends EComponentWithViewSupportHolder implements public EActivityHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); - instanceStateHolder = new InstanceStateHolder(this); + instanceStateHolder = new InstanceStateHolder(this); onActivityResultHolder = new OnActivityResultHolder(this); createIntentBuilder(); handleBackPressed(); @@ -209,7 +233,6 @@ private void setOnCreateOptionsMenu() { getMenuInflaterMethodName = "getSupportMenuInflater"; } - JMethod method = generatedClass.method(PUBLIC, codeModel().BOOLEAN, "onCreateOptionsMenu"); method.annotate(Override.class); JBlock methodBody = method.body(); @@ -326,6 +349,7 @@ private boolean usesGreenDroid() { } return greenDroidHelper.usesGreenDroid(annotatedElement); } + private void createIntentBuilder() throws JClassAlreadyExistsException { new ActivityIntentBuilder(this).build(); } @@ -388,7 +412,7 @@ private boolean isCustomOnBackPressedMethod(ExecutableElement method) { && method.getModifiers().contains(Modifier.PUBLIC) // && method.getReturnType().getKind().equals(TypeKind.VOID) // && method.getParameters().size() == 0 // - ; + ; } @Override @@ -419,7 +443,7 @@ public RoboGuiceHolder getRoboGuiceHolder() { } protected void setScopeField() { - getRoboGuiceHolder().scope = getGeneratedClass().field(JMod.PRIVATE, classes().CONTEXT_SCOPE, "scope_"); + getRoboGuiceHolder().scope = getGeneratedClass().field(JMod.PRIVATE, classes().CONTEXT_SCOPE, "scope_"); } protected void setEventManagerField() { @@ -468,25 +492,25 @@ private void setInjectExtras() { getInitBody().invoke(injectExtrasMethod); } - @Override - public JBlock getSaveStateMethodBody() { - return instanceStateHolder.getSaveStateMethodBody(); - } + @Override + public JBlock getSaveStateMethodBody() { + return instanceStateHolder.getSaveStateMethodBody(); + } - @Override - public JVar getSaveStateBundleParam() { - return instanceStateHolder.getSaveStateBundleParam(); - } + @Override + public JVar getSaveStateBundleParam() { + return instanceStateHolder.getSaveStateBundleParam(); + } - @Override - public JMethod getRestoreStateMethod() { - return instanceStateHolder.getRestoreStateMethod(); - } + @Override + public JMethod getRestoreStateMethod() { + return instanceStateHolder.getRestoreStateMethod(); + } - @Override - public JVar getRestoreStateBundleParam() { - return instanceStateHolder.getRestoreStateBundleParam(); - } + @Override + public JVar getRestoreStateBundleParam() { + return instanceStateHolder.getRestoreStateBundleParam(); + } @Override public JBlock getOnCreateOptionsMenuMethodBody() { @@ -568,7 +592,7 @@ private void setInitNonConfigurationInstance() throws JClassAlreadyExistsExcepti initIfNonConfigurationNotNullBlock = initBody._if(initNonConfigurationInstance.ne(_null()))._then(); } - public JMethod getGetLastNonConfigurationInstance() throws JClassAlreadyExistsException { + public JMethod getGetLastNonConfigurationInstance() throws JClassAlreadyExistsException { if (getLastNonConfigurationInstance == null) { setGetLastNonConfigurationInstance(); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EApplicationHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EApplicationHolder.java index 1912fa2013..e425325c65 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EApplicationHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EApplicationHolder.java @@ -15,14 +15,22 @@ */ package org.androidannotations.holder; -import com.sun.codemodel.*; -import org.androidannotations.process.ProcessHolder; +import static com.sun.codemodel.JExpr._super; +import static com.sun.codemodel.JExpr._this; +import static com.sun.codemodel.JMod.PRIVATE; +import static com.sun.codemodel.JMod.PUBLIC; +import static com.sun.codemodel.JMod.STATIC; import javax.lang.model.element.TypeElement; -import static com.sun.codemodel.JExpr._super; -import static com.sun.codemodel.JExpr._this; -import static com.sun.codemodel.JMod.*; +import org.androidannotations.process.ProcessHolder; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JFieldVar; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JVar; public class EApplicationHolder extends EComponentHolder { @@ -40,14 +48,14 @@ private void createSingleton() { JClass annotatedComponent = generatedClass._extends(); staticInstanceField = generatedClass.field(PRIVATE | STATIC, annotatedComponent, "INSTANCE_"); - // Static singleton getter and setter - JMethod getInstance = generatedClass.method(PUBLIC | STATIC, annotatedComponent, GET_APPLICATION_INSTANCE); - getInstance.body()._return(staticInstanceField); + // Static singleton getter and setter + JMethod getInstance = generatedClass.method(PUBLIC | STATIC, annotatedComponent, GET_APPLICATION_INSTANCE); + getInstance.body()._return(staticInstanceField); - JMethod setInstance = generatedClass.method(PUBLIC | STATIC, codeModel().VOID, "setForTesting"); - setInstance.javadoc().append("Visible for testing purposes"); - JVar applicationParam = setInstance.param(annotatedComponent, "application"); - setInstance.body().assign(staticInstanceField, applicationParam); + JMethod setInstance = generatedClass.method(PUBLIC | STATIC, codeModel().VOID, "setForTesting"); + setInstance.javadoc().append("Visible for testing purposes"); + JVar applicationParam = setInstance.param(annotatedComponent, "application"); + setInstance.body().assign(staticInstanceField, applicationParam); } private void createOnCreate() { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java index e611f07f2d..a8695c9327 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EBeanHolder.java @@ -15,21 +15,25 @@ */ package org.androidannotations.holder; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JFieldVar; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JVar; -import org.androidannotations.process.ProcessHolder; +import static com.sun.codemodel.JExpr._new; +import static com.sun.codemodel.JExpr._null; +import static com.sun.codemodel.JMod.PRIVATE; +import static com.sun.codemodel.JMod.PUBLIC; +import static com.sun.codemodel.JMod.STATIC; +import static org.androidannotations.helper.ModelConstants.GENERATION_SUFFIX; + +import java.util.List; import javax.lang.model.element.ExecutableElement; import javax.lang.model.element.TypeElement; import javax.lang.model.util.ElementFilter; -import java.util.List; -import static com.sun.codemodel.JExpr._new; -import static com.sun.codemodel.JExpr._null; -import static com.sun.codemodel.JMod.*; -import static org.androidannotations.helper.ModelConstants.GENERATION_SUFFIX; +import org.androidannotations.process.ProcessHolder; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JFieldVar; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JVar; public class EBeanHolder extends EComponentWithViewSupportHolder { @@ -66,6 +70,7 @@ public JFieldVar getContextField() { protected void setContextRef() { contextRef = getContextField(); } + protected void setInit() { init = generatedClass.method(PRIVATE, processHolder.codeModel().VOID, "init_"); JBlock constructorBody = constructor.body(); @@ -80,9 +85,9 @@ public void createFactoryMethod(boolean hasSingletonScope) { JBlock factoryMethodBody = factoryMethod.body(); - /* - * Singletons are bound to the application context - */ + /* + * Singletons are bound to the application context + */ if (hasSingletonScope) { JFieldVar instanceField = generatedClass.field(PRIVATE | STATIC, generatedClass, "instance_"); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java index 829c8f0938..b3c42f8993 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentHolder.java @@ -15,17 +15,26 @@ */ package org.androidannotations.holder; -import com.sun.codemodel.*; -import org.androidannotations.helper.CaseHelper; -import org.androidannotations.helper.ModelConstants; -import org.androidannotations.process.ProcessHolder; +import static com.sun.codemodel.JMod.PRIVATE; -import javax.lang.model.element.TypeElement; -import javax.lang.model.type.TypeMirror; import java.util.HashMap; import java.util.Map; -import static com.sun.codemodel.JMod.PRIVATE; +import javax.lang.model.element.TypeElement; +import javax.lang.model.type.TypeMirror; + +import org.androidannotations.helper.CaseHelper; +import org.androidannotations.helper.ModelConstants; +import org.androidannotations.process.ProcessHolder; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JFieldVar; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JMod; +import com.sun.codemodel.JVar; public abstract class EComponentHolder extends BaseGeneratedClassHolder { @@ -36,7 +45,7 @@ public abstract class EComponentHolder extends BaseGeneratedClassHolder { private JVar handler; public EComponentHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { - super(processHolder, annotatedElement); + super(processHolder, annotatedElement); } public JExpression getContextRef() { @@ -68,7 +77,7 @@ public JVar getResourcesRef() { return resourcesRef; } - private void setResourcesRef() { + private void setResourcesRef() { resourcesRef = getInitBody().decl(classes().RESOURCES, "resources_", getContextRef().invoke("getResources")); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentWithViewSupportHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentWithViewSupportHolder.java index b440bd02e3..55b84f58d8 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentWithViewSupportHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EComponentWithViewSupportHolder.java @@ -15,7 +15,20 @@ */ package org.androidannotations.holder; -import com.sun.codemodel.*; +import static com.sun.codemodel.JExpr._new; +import static com.sun.codemodel.JExpr._null; +import static com.sun.codemodel.JExpr._this; +import static com.sun.codemodel.JExpr.cast; +import static com.sun.codemodel.JExpr.invoke; +import static com.sun.codemodel.JMod.FINAL; +import static com.sun.codemodel.JMod.PRIVATE; +import static com.sun.codemodel.JMod.PUBLIC; + +import java.util.HashMap; + +import javax.lang.model.element.TypeElement; +import javax.lang.model.type.TypeMirror; + import org.androidannotations.api.view.HasViews; import org.androidannotations.api.view.OnViewChangedListener; import org.androidannotations.api.view.OnViewChangedNotifier; @@ -23,12 +36,14 @@ import org.androidannotations.helper.ViewNotifierHelper; import org.androidannotations.process.ProcessHolder; -import javax.lang.model.element.TypeElement; -import javax.lang.model.type.TypeMirror; -import java.util.HashMap; - -import static com.sun.codemodel.JExpr.*; -import static com.sun.codemodel.JMod.*; +import com.sun.codemodel.JBlock; +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.JVar; public abstract class EComponentWithViewSupportHolder extends EComponentHolder { @@ -179,7 +194,7 @@ private TextWatcherHolder createTextWatcherHolder(JFieldRef idRef, TypeMirror vi JBlock onViewChangedBody = getOnViewChangedBody().block(); JVar viewVariable = onViewChangedBody.decl(FINAL, viewClass, "view", cast(viewClass, findViewById(idRef))); onViewChangedBody._if(viewVariable.ne(JExpr._null()))._then() // - .invoke(viewVariable, "addTextChangedListener").arg(_new(onTextChangeListenerClass)); + .invoke(viewVariable, "addTextChangedListener").arg(_new(onTextChangeListenerClass)); return new TextWatcherHolder(this, viewVariable, onTextChangeListenerClass); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java index 3ae3787b8e..8a81ed04a8 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EFragmentHolder.java @@ -15,16 +15,32 @@ */ package org.androidannotations.holder; -import com.sun.codemodel.*; +import static com.sun.codemodel.JExpr.FALSE; +import static com.sun.codemodel.JExpr.TRUE; +import static com.sun.codemodel.JExpr._new; +import static com.sun.codemodel.JExpr._null; +import static com.sun.codemodel.JExpr._super; +import static com.sun.codemodel.JExpr.invoke; +import static com.sun.codemodel.JMod.PRIVATE; +import static com.sun.codemodel.JMod.PUBLIC; +import static com.sun.codemodel.JMod.STATIC; + +import javax.lang.model.element.TypeElement; + import org.androidannotations.helper.ActionBarSherlockHelper; import org.androidannotations.helper.AnnotationHelper; import org.androidannotations.helper.HoloEverywhereHelper; import org.androidannotations.process.ProcessHolder; -import javax.lang.model.element.TypeElement; - -import static com.sun.codemodel.JExpr.*; -import static com.sun.codemodel.JMod.*; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JClassAlreadyExistsException; +import com.sun.codemodel.JDefinedClass; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JFieldVar; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JMod; +import com.sun.codemodel.JVar; public class EFragmentHolder extends EComponentWithViewSupportHolder implements HasInstanceState, HasOptionsMenu, HasOnActivityResult { @@ -37,7 +53,7 @@ public class EFragmentHolder extends EComponentWithViewSupportHolder implements private JMethod injectArgsMethod; private JBlock injectArgsBlock; private JVar injectBundleArgs; - private InstanceStateHolder instanceStateHolder; + private InstanceStateHolder instanceStateHolder; private OnActivityResultHolder onActivityResultHolder; private JBlock onCreateOptionsMenuMethodBody; private JVar onCreateOptionsMenuMenuInflaterVar; @@ -48,7 +64,7 @@ public class EFragmentHolder extends EComponentWithViewSupportHolder implements public EFragmentHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { super(processHolder, annotatedElement); - instanceStateHolder = new InstanceStateHolder(this); + instanceStateHolder = new InstanceStateHolder(this); onActivityResultHolder = new OnActivityResultHolder(this); createOnCreate(); createOnViewCreated(); @@ -267,25 +283,25 @@ private void setInjectArgs() { getInitBody().invoke(injectArgsMethod); } - @Override - public JBlock getSaveStateMethodBody() { - return instanceStateHolder.getSaveStateMethodBody(); - } + @Override + public JBlock getSaveStateMethodBody() { + return instanceStateHolder.getSaveStateMethodBody(); + } - @Override - public JVar getSaveStateBundleParam() { - return instanceStateHolder.getSaveStateBundleParam(); - } + @Override + public JVar getSaveStateBundleParam() { + return instanceStateHolder.getSaveStateBundleParam(); + } - @Override - public JMethod getRestoreStateMethod() { - return instanceStateHolder.getRestoreStateMethod(); - } + @Override + public JMethod getRestoreStateMethod() { + return instanceStateHolder.getRestoreStateMethod(); + } - @Override - public JVar getRestoreStateBundleParam() { - return instanceStateHolder.getRestoreStateBundleParam(); - } + @Override + public JVar getRestoreStateBundleParam() { + return instanceStateHolder.getRestoreStateBundleParam(); + } @Override public JBlock getOnCreateOptionsMenuMethodBody() { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EProviderHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EProviderHolder.java index 9111394186..d0ccb21869 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EProviderHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EProviderHolder.java @@ -15,17 +15,18 @@ */ package org.androidannotations.holder; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JMethod; -import org.androidannotations.process.ProcessHolder; - -import javax.lang.model.element.TypeElement; - import static com.sun.codemodel.JExpr._super; import static com.sun.codemodel.JExpr.invoke; import static com.sun.codemodel.JMod.PRIVATE; import static com.sun.codemodel.JMod.PUBLIC; +import javax.lang.model.element.TypeElement; + +import org.androidannotations.process.ProcessHolder; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JMethod; + public class EProviderHolder extends EComponentHolder { public EProviderHolder(ProcessHolder processHolder, TypeElement annotatedElement) throws Exception { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EReceiverHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EReceiverHolder.java index 38cb59065f..62e2028cca 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EReceiverHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EReceiverHolder.java @@ -15,13 +15,18 @@ */ package org.androidannotations.holder; -import com.sun.codemodel.*; -import org.androidannotations.process.ProcessHolder; +import static com.sun.codemodel.JMod.PRIVATE; +import static com.sun.codemodel.JMod.PUBLIC; import javax.lang.model.element.TypeElement; -import static com.sun.codemodel.JMod.PRIVATE; -import static com.sun.codemodel.JMod.PUBLIC; +import org.androidannotations.process.ProcessHolder; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JFieldVar; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JVar; public class EReceiverHolder extends EComponentHolder { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EServiceHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EServiceHolder.java index 26e22867e6..9565aca17b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EServiceHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EServiceHolder.java @@ -15,16 +15,22 @@ */ package org.androidannotations.holder; -import com.sun.codemodel.*; -import org.androidannotations.helper.ServiceIntentBuilder; -import org.androidannotations.process.ProcessHolder; - -import javax.lang.model.element.TypeElement; - import static com.sun.codemodel.JExpr._this; import static com.sun.codemodel.JMod.PRIVATE; import static com.sun.codemodel.JMod.PUBLIC; +import javax.lang.model.element.TypeElement; + +import org.androidannotations.helper.ServiceIntentBuilder; +import org.androidannotations.process.ProcessHolder; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClassAlreadyExistsException; +import com.sun.codemodel.JDefinedClass; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JFieldVar; +import com.sun.codemodel.JMethod; + public class EServiceHolder extends EComponentHolder implements HasIntentBuilder { private JDefinedClass intentBuilderClass; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewGroupHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewGroupHolder.java index 4dc0562333..c986de15fd 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewGroupHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewGroupHolder.java @@ -15,13 +15,14 @@ */ package org.androidannotations.holder; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JExpr; -import org.androidannotations.process.ProcessHolder; +import static com.sun.codemodel.JMod.PUBLIC; import javax.lang.model.element.TypeElement; -import static com.sun.codemodel.JMod.PUBLIC; +import org.androidannotations.process.ProcessHolder; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JExpr; public class EViewGroupHolder extends EViewHolder { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java index a44dc0047b..d6b4777604 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EViewHolder.java @@ -15,17 +15,34 @@ */ package org.androidannotations.holder; -import com.sun.codemodel.*; -import org.androidannotations.helper.ModelConstants; -import org.androidannotations.process.ProcessHolder; +import static com.sun.codemodel.JExpr.invoke; +import static com.sun.codemodel.JMod.PRIVATE; +import static com.sun.codemodel.JMod.PUBLIC; +import static com.sun.codemodel.JMod.STATIC; +import static javax.lang.model.element.ElementKind.CONSTRUCTOR; -import javax.lang.model.element.*; import java.util.ArrayList; import java.util.List; -import static com.sun.codemodel.JExpr.invoke; -import static com.sun.codemodel.JMod.*; -import static javax.lang.model.element.ElementKind.CONSTRUCTOR; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.Modifier; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.VariableElement; + +import org.androidannotations.helper.ModelConstants; +import org.androidannotations.process.ProcessHolder; + +import com.sun.codemodel.ClassType; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JFieldVar; +import com.sun.codemodel.JInvocation; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JMod; +import com.sun.codemodel.JType; +import com.sun.codemodel.JVar; public class EViewHolder extends EComponentWithViewSupportHolder { @@ -34,14 +51,14 @@ public class EViewHolder extends EComponentWithViewSupportHolder { + "which leads to infinite calls of onFinishInflate()\n" // + "when inflating a layout with a parent and using\n" // + "the tag." // - ; + ; private static final String SUPPRESS_WARNING_COMMENT = "" // + "We use @SuppressWarning here because our java code\n" // + "generator doesn't know that there is no need\n" // + "to import OnXXXListeners from View as we already\n" // + "are in a View." // - ; + ; protected JBlock initBody; protected JMethod onFinishInflate; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/GeneratedClassHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/GeneratedClassHolder.java index 746a5fdac7..4e920cb12d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/GeneratedClassHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/GeneratedClassHolder.java @@ -15,24 +15,32 @@ */ package org.androidannotations.holder; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JDefinedClass; -import org.androidannotations.process.ProcessHolder; - import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; import javax.lang.model.element.TypeElement; +import org.androidannotations.process.ProcessHolder; + +import com.sun.codemodel.JClass; +import com.sun.codemodel.JCodeModel; +import com.sun.codemodel.JDefinedClass; + public interface GeneratedClassHolder { - JDefinedClass getGeneratedClass(); - TypeElement getAnnotatedElement(); - - public ProcessingEnvironment processingEnvironment(); - public ProcessHolder.Classes classes(); - public JCodeModel codeModel(); - public JClass refClass(String fullyQualifiedClassName); - public JClass refClass(Class clazz); - public JDefinedClass definedClass(String fullyQualifiedClassName); - public void generateApiClass(Element originatingElement, Class apiClass); + JDefinedClass getGeneratedClass(); + + TypeElement getAnnotatedElement(); + + public ProcessingEnvironment processingEnvironment(); + + public ProcessHolder.Classes classes(); + + public JCodeModel codeModel(); + + public JClass refClass(String fullyQualifiedClassName); + + public JClass refClass(Class clazz); + + public JDefinedClass definedClass(String fullyQualifiedClassName); + + public void generateApiClass(Element originatingElement, Class apiClass); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasExtras.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasExtras.java index 7685002977..e6102da125 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasExtras.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasExtras.java @@ -21,6 +21,8 @@ public interface HasExtras extends GeneratedClassHolder { JMethod getInjectExtrasMethod(); + JBlock getInjectExtrasBlock(); + JVar getInjectExtras(); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasInstanceState.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasInstanceState.java index 94104c43e2..e3d366cd1a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasInstanceState.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasInstanceState.java @@ -15,11 +15,16 @@ */ package org.androidannotations.holder; -import com.sun.codemodel.*; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JVar; public interface HasInstanceState extends GeneratedClassHolder { - JBlock getSaveStateMethodBody(); - JVar getSaveStateBundleParam(); - JMethod getRestoreStateMethod(); - JVar getRestoreStateBundleParam(); + JBlock getSaveStateMethodBody(); + + JVar getSaveStateBundleParam(); + + JMethod getRestoreStateMethod(); + + JVar getRestoreStateBundleParam(); } \ No newline at end of file diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasIntentBuilder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasIntentBuilder.java index 1cb2f4fb10..cb781514b2 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasIntentBuilder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasIntentBuilder.java @@ -21,8 +21,10 @@ public interface HasIntentBuilder extends GeneratedClassHolder { public void setIntentBuilderClass(JDefinedClass intentBuilderClass); + public JDefinedClass getIntentBuilderClass(); public void setIntentField(JFieldVar intentField); + public JFieldVar getIntentField(); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOnActivityResult.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOnActivityResult.java index e16306d764..eec68c1c93 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOnActivityResult.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOnActivityResult.java @@ -20,6 +20,8 @@ public interface HasOnActivityResult extends GeneratedClassHolder { JBlock getOnActivityResultCaseBlock(int requestCode); + JVar getOnActivityResultDataParam(); + JVar getOnActivityResultResultCodeParam(); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOptionsMenu.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOptionsMenu.java index 0f442b9afd..97e001c0e6 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOptionsMenu.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/HasOptionsMenu.java @@ -20,10 +20,14 @@ public interface HasOptionsMenu extends GeneratedClassHolder { JBlock getOnCreateOptionsMenuMethodBody(); + JVar getOnCreateOptionsMenuMenuInflaterVar(); + JVar getOnCreateOptionsMenuMenuParam(); JVar getOnOptionsItemSelectedItem(); + JVar getOnOptionsItemSelectedItemId(); + JBlock getOnOptionsItemSelectedIfElseBlock(); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/InstanceStateHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/InstanceStateHolder.java index 9bdbbf8271..b9fa27310f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/InstanceStateHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/InstanceStateHolder.java @@ -15,90 +15,97 @@ */ package org.androidannotations.holder; -import com.sun.codemodel.*; -import org.androidannotations.process.ProcessHolder; +import static com.sun.codemodel.JExpr._null; +import static com.sun.codemodel.JExpr.ref; +import static com.sun.codemodel.JMod.PRIVATE; +import static com.sun.codemodel.JMod.PUBLIC; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; import javax.lang.model.element.TypeElement; -import static com.sun.codemodel.JExpr._null; -import static com.sun.codemodel.JExpr.ref; -import static com.sun.codemodel.JMod.PRIVATE; -import static com.sun.codemodel.JMod.PUBLIC; +import org.androidannotations.process.ProcessHolder; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JCodeModel; +import com.sun.codemodel.JDefinedClass; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JVar; public class InstanceStateHolder implements HasInstanceState { - private EComponentHolder holder; - private JBlock saveStateMethodBody; - private JVar saveStateBundleParam; - private JMethod restoreStateMethod; - private JVar restoreStateBundleParam; - - public InstanceStateHolder(EComponentHolder holder) { - this.holder = holder; - } - - @Override - public JBlock getSaveStateMethodBody() { - if (saveStateMethodBody == null) { - setSaveStateMethod(); - } - return saveStateMethodBody; - } - - @Override - public JVar getSaveStateBundleParam() { - if (saveStateBundleParam == null) { - setSaveStateMethod(); - } - return saveStateBundleParam; - } - - private void setSaveStateMethod() { - JMethod method = getGeneratedClass().method(PUBLIC, codeModel().VOID, "onSaveInstanceState"); - method.annotate(Override.class); - saveStateBundleParam = method.param(classes().BUNDLE, "bundle"); - - saveStateMethodBody = method.body(); - - saveStateMethodBody.invoke(JExpr._super(), "onSaveInstanceState").arg(saveStateBundleParam); - } - - @Override - public JMethod getRestoreStateMethod() { - if (restoreStateMethod == null) { - setRestoreStateMethod(); - } - return restoreStateMethod; - } - - @Override - public JVar getRestoreStateBundleParam() { - if (restoreStateBundleParam == null) { - setRestoreStateMethod(); - } - return restoreStateBundleParam; - } - - private void setRestoreStateMethod() { - restoreStateMethod = getGeneratedClass().method(PRIVATE, codeModel().VOID, "restoreSavedInstanceState_"); - restoreStateBundleParam = restoreStateMethod.param(classes().BUNDLE, "savedInstanceState"); - getInit().body().invoke(restoreStateMethod).arg(restoreStateBundleParam); - - restoreStateMethod.body() // - ._if(ref("savedInstanceState").eq(_null())) // - ._then()._return(); - } + private EComponentHolder holder; + private JBlock saveStateMethodBody; + private JVar saveStateBundleParam; + private JMethod restoreStateMethod; + private JVar restoreStateBundleParam; + + public InstanceStateHolder(EComponentHolder holder) { + this.holder = holder; + } + + @Override + public JBlock getSaveStateMethodBody() { + if (saveStateMethodBody == null) { + setSaveStateMethod(); + } + return saveStateMethodBody; + } + + @Override + public JVar getSaveStateBundleParam() { + if (saveStateBundleParam == null) { + setSaveStateMethod(); + } + return saveStateBundleParam; + } + + private void setSaveStateMethod() { + JMethod method = getGeneratedClass().method(PUBLIC, codeModel().VOID, "onSaveInstanceState"); + method.annotate(Override.class); + saveStateBundleParam = method.param(classes().BUNDLE, "bundle"); + + saveStateMethodBody = method.body(); + + saveStateMethodBody.invoke(JExpr._super(), "onSaveInstanceState").arg(saveStateBundleParam); + } + + @Override + public JMethod getRestoreStateMethod() { + if (restoreStateMethod == null) { + setRestoreStateMethod(); + } + return restoreStateMethod; + } + + @Override + public JVar getRestoreStateBundleParam() { + if (restoreStateBundleParam == null) { + setRestoreStateMethod(); + } + return restoreStateBundleParam; + } + + private void setRestoreStateMethod() { + restoreStateMethod = getGeneratedClass().method(PRIVATE, codeModel().VOID, "restoreSavedInstanceState_"); + restoreStateBundleParam = restoreStateMethod.param(classes().BUNDLE, "savedInstanceState"); + getInit().body().invoke(restoreStateMethod).arg(restoreStateBundleParam); + + restoreStateMethod.body() // + ._if(ref("savedInstanceState").eq(_null())) // + ._then()._return(); + } public JMethod getInit() { return holder.getInit(); } @Override - public JDefinedClass getGeneratedClass() { - return holder.getGeneratedClass(); - } + public JDefinedClass getGeneratedClass() { + return holder.getGeneratedClass(); + } @Override public JCodeModel codeModel() { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/NonConfigurationHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/NonConfigurationHolder.java index 967d0b36e2..688a39fe93 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/NonConfigurationHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/NonConfigurationHolder.java @@ -15,10 +15,14 @@ */ package org.androidannotations.holder; -import com.sun.codemodel.*; - import static com.sun.codemodel.JMod.PUBLIC; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JClassAlreadyExistsException; +import com.sun.codemodel.JDefinedClass; +import com.sun.codemodel.JFieldVar; +import com.sun.codemodel.JMod; + public class NonConfigurationHolder { private JDefinedClass generatedClass; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/OnActivityResultHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/OnActivityResultHolder.java index ca2da37895..a5346282da 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/OnActivityResultHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/OnActivityResultHolder.java @@ -15,12 +15,20 @@ */ package org.androidannotations.holder; -import com.sun.codemodel.*; -import org.androidannotations.process.ProcessHolder; +import static com.sun.codemodel.JExpr._super; import java.util.HashMap; -import static com.sun.codemodel.JExpr._super; +import org.androidannotations.process.ProcessHolder; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JCase; +import com.sun.codemodel.JCodeModel; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JMod; +import com.sun.codemodel.JSwitch; +import com.sun.codemodel.JVar; public class OnActivityResultHolder { @@ -99,7 +107,7 @@ private void setOnActivityResult() { dataParam = method.param(classes().INTENT, "data"); JBlock body = method.body(); body.invoke(_super(), method).arg(requestCodeParam).arg(resultCodeParam).arg(dataParam); - afterSuperBlock = body.block(); + afterSuperBlock = body.block(); } private JCodeModel codeModel() { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/OnSeekBarChangeListenerHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/OnSeekBarChangeListenerHolder.java index 79577c4230..677f1ad64c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/OnSeekBarChangeListenerHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/OnSeekBarChangeListenerHolder.java @@ -15,7 +15,11 @@ */ package org.androidannotations.holder; -import com.sun.codemodel.*; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JDefinedClass; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JMod; +import com.sun.codemodel.JVar; public class OnSeekBarChangeListenerHolder { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RestHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RestHolder.java index eea756b69b..a3eab3d163 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RestHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RestHolder.java @@ -15,9 +15,14 @@ */ package org.androidannotations.holder; -import com.sun.codemodel.*; -import org.androidannotations.helper.ModelConstants; -import org.androidannotations.process.ProcessHolder; +import static com.sun.codemodel.JExpr._new; +import static com.sun.codemodel.JExpr._this; +import static com.sun.codemodel.JMod.FINAL; +import static com.sun.codemodel.JMod.PUBLIC; +import static org.androidannotations.helper.CanonicalNameConstants.REST_TEMPLATE; +import static org.androidannotations.helper.CanonicalNameConstants.STRING; + +import java.util.List; import javax.lang.model.element.Element; import javax.lang.model.element.ExecutableElement; @@ -25,18 +30,20 @@ import javax.lang.model.element.VariableElement; import javax.lang.model.type.TypeKind; import javax.lang.model.util.ElementFilter; -import java.util.List; -import static com.sun.codemodel.JExpr._new; -import static com.sun.codemodel.JExpr._this; -import static com.sun.codemodel.JMod.FINAL; -import static com.sun.codemodel.JMod.PUBLIC; -import static org.androidannotations.helper.CanonicalNameConstants.REST_TEMPLATE; -import static org.androidannotations.helper.CanonicalNameConstants.STRING; +import org.androidannotations.helper.ModelConstants; +import org.androidannotations.process.ProcessHolder; + +import com.sun.codemodel.ClassType; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JFieldVar; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JMod; +import com.sun.codemodel.JVar; public class RestHolder extends BaseGeneratedClassHolder { - private JMethod init; + private JMethod init; private JFieldVar rootUrlField; private JFieldVar restTemplateField; @@ -70,25 +77,24 @@ private void implementMethods() { } if (!setRestTemplateImplemented // - && parameters.size() == 1 // - && parameters.get(0).asType().toString().equals(REST_TEMPLATE) // - && method.getReturnType().getKind() == TypeKind.VOID) { + && parameters.size() == 1 // + && parameters.get(0).asType().toString().equals(REST_TEMPLATE) // + && method.getReturnType().getKind() == TypeKind.VOID) { implementSetRestTemplateMethod(method); setRestTemplateImplemented = true; } - if (!getRootUrlImplemented // - && parameters.size() == 0 // - && method.getReturnType().toString().equals(STRING) // - && method.getSimpleName().toString().equals("getRootUrl")) { - implementGetRootUrlMethod(method); - getRootUrlImplemented = true; - } + if (!getRootUrlImplemented // + && parameters.size() == 0 // + && method.getReturnType().toString().equals(STRING) // + && method.getSimpleName().toString().equals("getRootUrl")) { + implementGetRootUrlMethod(method); + getRootUrlImplemented = true; + } if (!setRootUrlImplemented // - && method.getSimpleName().toString().equals("setRootUrl") - && method.getReturnType().getKind() == TypeKind.VOID // + && method.getSimpleName().toString().equals("setRootUrl") && method.getReturnType().getKind() == TypeKind.VOID // && parameters.size() == 1 // && parameters.get(0).asType().toString().equals(STRING)) { @@ -114,12 +120,12 @@ private void implementSetRestTemplateMethod(ExecutableElement method) { setRestTemplateMethod.body().assign(_this().ref(getRestTemplateField()), restTemplateSetterParam); } - private void implementGetRootUrlMethod(ExecutableElement method) { - String methodName = method.getSimpleName().toString(); - JMethod getRootUrlMethod = getGeneratedClass().method(JMod.PUBLIC, processHolder.refClass(STRING), methodName); - getRootUrlMethod.annotate(Override.class); - getRootUrlMethod.body()._return(getRootUrlField()); - } + private void implementGetRootUrlMethod(ExecutableElement method) { + String methodName = method.getSimpleName().toString(); + JMethod getRootUrlMethod = getGeneratedClass().method(JMod.PUBLIC, processHolder.refClass(STRING), methodName); + getRootUrlMethod.annotate(Override.class); + getRootUrlMethod.body()._return(getRootUrlField()); + } private void implementSetRootUrl(ExecutableElement method) { String methodName = method.getSimpleName().toString(); @@ -130,12 +136,12 @@ private void implementSetRootUrl(ExecutableElement method) { setRootUrlMethod.body().assign(_this().ref(getRootUrlField()), rootUrlSetterParam); } - public JMethod getInit() { - if (init == null) { - setInit(); - } - return init; - } + public JMethod getInit() { + if (init == null) { + setInit(); + } + return init; + } private void setInit() { init = getGeneratedClass().constructor(JMod.PUBLIC); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java index 8a34ef2b57..3b0ef07c48 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java @@ -15,11 +15,12 @@ */ package org.androidannotations.holder; +import org.androidannotations.process.ProcessHolder; + import com.sun.codemodel.JBlock; import com.sun.codemodel.JFieldVar; import com.sun.codemodel.JMethod; import com.sun.codemodel.JVar; -import org.androidannotations.process.ProcessHolder; public class RoboGuiceHolder { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/SharedPrefHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/SharedPrefHolder.java index a90fb9ee04..77795b8076 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/SharedPrefHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/SharedPrefHolder.java @@ -15,19 +15,37 @@ */ package org.androidannotations.holder; -import com.sun.codemodel.*; -import org.androidannotations.api.sharedpreferences.*; -import org.androidannotations.helper.CanonicalNameConstants; -import org.androidannotations.helper.ModelConstants; -import org.androidannotations.process.ProcessHolder; +import static com.sun.codemodel.JMod.FINAL; +import static com.sun.codemodel.JMod.PUBLIC; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.TypeElement; import java.util.HashMap; import java.util.Map; -import static com.sun.codemodel.JMod.FINAL; -import static com.sun.codemodel.JMod.PUBLIC; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.TypeElement; + +import org.androidannotations.api.sharedpreferences.BooleanPrefEditorField; +import org.androidannotations.api.sharedpreferences.EditorHelper; +import org.androidannotations.api.sharedpreferences.FloatPrefEditorField; +import org.androidannotations.api.sharedpreferences.IntPrefEditorField; +import org.androidannotations.api.sharedpreferences.LongPrefEditorField; +import org.androidannotations.api.sharedpreferences.SharedPreferencesHelper; +import org.androidannotations.api.sharedpreferences.StringPrefEditorField; +import org.androidannotations.helper.CanonicalNameConstants; +import org.androidannotations.helper.ModelConstants; +import org.androidannotations.process.ProcessHolder; + +import com.sun.codemodel.ClassType; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JClassAlreadyExistsException; +import com.sun.codemodel.JDefinedClass; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JFieldVar; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JMod; +import com.sun.codemodel.JVar; public class SharedPrefHolder extends BaseGeneratedClassHolder { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/TextWatcherHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/TextWatcherHolder.java index 55bf09a5c5..c8b2500c51 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/TextWatcherHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/TextWatcherHolder.java @@ -15,7 +15,12 @@ */ package org.androidannotations.holder; -import com.sun.codemodel.*; +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JDefinedClass; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JMod; +import com.sun.codemodel.JPrimitiveType; +import com.sun.codemodel.JVar; public class TextWatcherHolder { 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 75b2e6fe54..b32b1b5824 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/AndroidRes.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/AndroidRes.java @@ -15,13 +15,29 @@ */ package org.androidannotations.model; -import org.androidannotations.annotations.res.*; -import org.androidannotations.rclass.IRClass.Res; - import java.lang.annotation.Annotation; import java.util.Arrays; import java.util.List; +import org.androidannotations.annotations.res.AnimationRes; +import org.androidannotations.annotations.res.BooleanRes; +import org.androidannotations.annotations.res.ColorRes; +import org.androidannotations.annotations.res.ColorStateListRes; +import org.androidannotations.annotations.res.DimensionPixelOffsetRes; +import org.androidannotations.annotations.res.DimensionPixelSizeRes; +import org.androidannotations.annotations.res.DimensionRes; +import org.androidannotations.annotations.res.DrawableRes; +import org.androidannotations.annotations.res.HtmlRes; +import org.androidannotations.annotations.res.IntArrayRes; +import org.androidannotations.annotations.res.IntegerRes; +import org.androidannotations.annotations.res.LayoutRes; +import org.androidannotations.annotations.res.MovieRes; +import org.androidannotations.annotations.res.StringArrayRes; +import org.androidannotations.annotations.res.StringRes; +import org.androidannotations.annotations.res.TextArrayRes; +import org.androidannotations.annotations.res.TextRes; +import org.androidannotations.rclass.IRClass.Res; + public enum AndroidRes { STRING(Res.STRING, StringRes.class, "getString", "java.lang.String"), // diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/AndroidSystemServices.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/AndroidSystemServices.java index be7fda982b..e13d46c1e5 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/AndroidSystemServices.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/AndroidSystemServices.java @@ -15,13 +15,15 @@ */ package org.androidannotations.model; -import com.sun.codemodel.JFieldRef; -import org.androidannotations.holder.EComponentHolder; - -import javax.lang.model.type.TypeMirror; import java.util.HashMap; import java.util.Map; +import javax.lang.model.type.TypeMirror; + +import org.androidannotations.holder.EComponentHolder; + +import com.sun.codemodel.JFieldRef; + public class AndroidSystemServices { private Map registeredServices = new HashMap(); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/ModelExtractor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/ModelExtractor.java index 759e9a70b0..bbd4ab4b3f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/ModelExtractor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/model/ModelExtractor.java @@ -15,6 +15,10 @@ */ package org.androidannotations.model; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + import javax.annotation.processing.RoundEnvironment; import javax.lang.model.element.AnnotationMirror; import javax.lang.model.element.Element; @@ -23,9 +27,6 @@ import javax.lang.model.type.DeclaredType; import javax.lang.model.type.TypeKind; import javax.lang.model.type.TypeMirror; -import java.util.HashSet; -import java.util.List; -import java.util.Set; public class ModelExtractor { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ModelProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ModelProcessor.java index 9cfb7f4f3b..9f7bd7382a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ModelProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ModelProcessor.java @@ -15,7 +15,14 @@ */ package org.androidannotations.process; -import com.sun.codemodel.JCodeModel; +import java.util.Set; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ElementKind; +import javax.lang.model.element.Modifier; +import javax.lang.model.element.TypeElement; + import org.androidannotations.handler.AnnotationHandler; import org.androidannotations.handler.AnnotationHandlers; import org.androidannotations.handler.GeneratingAnnotationHandler; @@ -23,12 +30,7 @@ import org.androidannotations.model.AnnotationElements; import org.androidannotations.model.AnnotationElements.AnnotatedAndRootElements; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ElementKind; -import javax.lang.model.element.Modifier; -import javax.lang.model.element.TypeElement; -import java.util.Set; +import com.sun.codemodel.JCodeModel; public class ModelProcessor { @@ -57,7 +59,7 @@ public ModelProcessor(ProcessingEnvironment processingEnv, AnnotationHandlers an this.annotationHandlers = annotationHandlers; } - @SuppressWarnings("unchecked") + @SuppressWarnings({ "unchecked", "rawtypes" }) public ProcessResult process(AnnotationElements validatedModel) throws Exception { ProcessHolder processHolder = new ProcessHolder(processingEnv); @@ -88,8 +90,8 @@ public ProcessResult process(AnnotationElements validatedModel) throws Exception String annotationName = annotationHandler.getTarget(); /* - * For ancestors, the annotationHandler manipulates the annotated elements, - * but uses the holder for the root element + * For ancestors, the annotationHandler manipulates the annotated + * elements, but uses the holder for the root element */ Set ancestorAnnotatedElements = validatedModel.getAncestorAnnotatedElements(annotationName); for (AnnotatedAndRootElements elements : ancestorAnnotatedElements) { @@ -119,7 +121,7 @@ public ProcessResult process(AnnotationElements validatedModel) throws Exception * classes, because the generated classes are final anyway */ if (!isAbstractClass(enclosingElement)) { - GeneratedClassHolder holder = processHolder.getGeneratedClassHolder(enclosingElement); + GeneratedClassHolder holder = processHolder.getGeneratedClassHolder(enclosingElement); annotationHandler.process(annotatedElement, holder); } } @@ -132,8 +134,6 @@ public ProcessResult process(AnnotationElements validatedModel) throws Exception processHolder.getApiClassesToGenerate()); } - - private boolean isAbstractClass(Element annotatedElement) { if (annotatedElement instanceof TypeElement) { TypeElement typeElement = (TypeElement) annotatedElement; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ModelValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ModelValidator.java index ed1957c76d..90a10e50ec 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ModelValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ModelValidator.java @@ -15,15 +15,16 @@ */ package org.androidannotations.process; +import java.util.HashSet; +import java.util.Set; + +import javax.lang.model.element.Element; + import org.androidannotations.handler.AnnotationHandler; import org.androidannotations.handler.AnnotationHandlers; import org.androidannotations.model.AnnotationElements; import org.androidannotations.model.AnnotationElementsHolder; -import javax.lang.model.element.Element; -import java.util.HashSet; -import java.util.Set; - public class ModelValidator { private AnnotationHandlers annotationHandlers; @@ -41,7 +42,7 @@ public AnnotationElements validate(AnnotationElementsHolder extractedModel) { */ AnnotationElementsHolder validatedElements = extractedModel.validatingHolder(); - for (AnnotationHandler annotationHandler : annotationHandlers.get()) { + for (AnnotationHandler annotationHandler : annotationHandlers.get()) { String annotationName = annotationHandler.getTarget(); Set annotatedElements = extractedModel.getRootAnnotatedElements(annotationName); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/OriginatingElements.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/OriginatingElements.java index 5865b56cb9..cff4827a33 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/OriginatingElements.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/OriginatingElements.java @@ -15,12 +15,13 @@ */ package org.androidannotations.process; -import javax.lang.model.element.Element; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; +import javax.lang.model.element.Element; + public class OriginatingElements { private final Map> originatingElementsByClassName = new HashMap>(); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ProcessHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ProcessHolder.java index 99b4217d30..9deb249c88 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ProcessHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ProcessHolder.java @@ -15,20 +15,26 @@ */ package org.androidannotations.process; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JClassAlreadyExistsException; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JDefinedClass; -import org.androidannotations.helper.CanonicalNameConstants; -import org.androidannotations.holder.GeneratedClassHolder; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; import java.io.FileInputStream; import java.io.InputStream; import java.io.Serializable; import java.sql.SQLException; -import java.util.*; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.Set; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + +import org.androidannotations.helper.CanonicalNameConstants; +import org.androidannotations.holder.GeneratedClassHolder; + +import com.sun.codemodel.JClass; +import com.sun.codemodel.JClassAlreadyExistsException; +import com.sun.codemodel.JCodeModel; +import com.sun.codemodel.JDefinedClass; public class ProcessHolder { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/CoumpoundInnerClass.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/CoumpoundInnerClass.java index 5d5a2d1d0e..d6fba13787 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/CoumpoundInnerClass.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/CoumpoundInnerClass.java @@ -15,9 +15,10 @@ */ package org.androidannotations.rclass; -import com.sun.codemodel.JFieldRef; import org.androidannotations.holder.GeneratedClassHolder; +import com.sun.codemodel.JFieldRef; + public class CoumpoundInnerClass implements IRInnerClass { private final IRInnerClass rInnerClass; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/IRInnerClass.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/IRInnerClass.java index 89273c2985..fcbe2f48dd 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/IRInnerClass.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/IRInnerClass.java @@ -15,9 +15,10 @@ */ package org.androidannotations.rclass; -import com.sun.codemodel.JFieldRef; import org.androidannotations.holder.GeneratedClassHolder; +import com.sun.codemodel.JFieldRef; + public interface IRInnerClass { boolean containsIdValue(Integer idValue); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/RInnerClass.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/RInnerClass.java index 7a27b1011f..19418dd8cb 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/RInnerClass.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/RInnerClass.java @@ -15,17 +15,23 @@ */ package org.androidannotations.rclass; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JFieldRef; -import org.androidannotations.helper.CaseHelper; -import org.androidannotations.holder.GeneratedClassHolder; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; import javax.lang.model.element.Element; import javax.lang.model.element.TypeElement; import javax.lang.model.element.VariableElement; import javax.lang.model.type.TypeKind; import javax.lang.model.util.ElementFilter; -import java.util.*; + +import org.androidannotations.helper.CaseHelper; +import org.androidannotations.holder.GeneratedClassHolder; + +import com.sun.codemodel.JClass; +import com.sun.codemodel.JFieldRef; public class RInnerClass implements IRInnerClass { @@ -110,16 +116,16 @@ public JFieldRef getIdStaticRef(String name, GeneratedClassHolder holder) { return extractIdStaticRef(holder, layoutFieldQualifiedName); } - public static JFieldRef extractIdStaticRef(GeneratedClassHolder holder, String layoutFieldQualifiedName) { - if (layoutFieldQualifiedName != null) { - int fieldSuffix = layoutFieldQualifiedName.lastIndexOf('.'); - String fieldName = layoutFieldQualifiedName.substring(fieldSuffix + 1); - String rInnerClassName = layoutFieldQualifiedName.substring(0, fieldSuffix); - - JClass refClass = holder.refClass(rInnerClassName); - return refClass.staticRef(fieldName); - } else { - return null; - } - } + public static JFieldRef extractIdStaticRef(GeneratedClassHolder holder, String layoutFieldQualifiedName) { + if (layoutFieldQualifiedName != null) { + int fieldSuffix = layoutFieldQualifiedName.lastIndexOf('.'); + String fieldName = layoutFieldQualifiedName.substring(fieldSuffix + 1); + String rInnerClassName = layoutFieldQualifiedName.substring(0, fieldSuffix); + + JClass refClass = holder.refClass(rInnerClassName); + return refClass.staticRef(fieldName); + } else { + return null; + } + } } diff --git a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/com/xtremelabs/robolectric/shadows/CustomShadowBundle.java b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/com/xtremelabs/robolectric/shadows/CustomShadowBundle.java index 7349b2d770..e19d96ee31 100644 --- a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/com/xtremelabs/robolectric/shadows/CustomShadowBundle.java +++ b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/com/xtremelabs/robolectric/shadows/CustomShadowBundle.java @@ -34,7 +34,7 @@ @Implements(Bundle.class) public class CustomShadowBundle { - Map mMap; + Map mMap; public CustomShadowBundle() { mMap = new HashMap(); @@ -131,12 +131,14 @@ public void putParcelableArray(String key, Parcelable[] value) { } @Implementation - public void putParcelableArrayList(String key, ArrayList value) { + public void putParcelableArrayList(String key, + ArrayList value) { mMap.put(key, value); } @Implementation - public void putSparseParcelableArray(String key, SparseArray value) { + public void putSparseParcelableArray(String key, + SparseArray value) { mMap.put(key, value); } @@ -428,7 +430,8 @@ public ArrayList getParcelableArrayList(String key) { } @Implementation - public SparseArray getSparseParcelableArray(String key) { + public SparseArray getSparseParcelableArray( + String key) { Object o = mMap.get(key); if (o == null) { return null; @@ -622,7 +625,4 @@ public boolean equals(Object obj) { return true; } - - - } diff --git a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/com/xtremelabs/robolectric/shadows/ShadowButton.java b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/com/xtremelabs/robolectric/shadows/ShadowButton.java index 244742a18b..5dbc92dfd8 100644 --- a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/com/xtremelabs/robolectric/shadows/ShadowButton.java +++ b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/com/xtremelabs/robolectric/shadows/ShadowButton.java @@ -36,7 +36,8 @@ public boolean performLongClick() { } @Implementation - public void setOnLongClickListener(View.OnLongClickListener onLongClickListener) { + public void setOnLongClickListener( + View.OnLongClickListener onLongClickListener) { this.onLongClickListener = onLongClickListener; } diff --git a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/com/xtremelabs/robolectric/shadows/ShadowListFragment.java b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/com/xtremelabs/robolectric/shadows/ShadowListFragment.java index ab5adcd6ab..ca66328564 100644 --- a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/com/xtremelabs/robolectric/shadows/ShadowListFragment.java +++ b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/com/xtremelabs/robolectric/shadows/ShadowListFragment.java @@ -27,12 +27,13 @@ @Implements(ListFragment.class) public class ShadowListFragment extends ShadowFragment { - final private AdapterView.OnItemClickListener mOnClickListener = // - new AdapterView.OnItemClickListener() { - public void onItemClick(AdapterView parent, View v, int position, long id) { - onListItemClick((ListView) parent, v, position, id); - } - }; + final private AdapterView.OnItemClickListener mOnClickListener = // + new AdapterView.OnItemClickListener() { + public void onItemClick(AdapterView parent, View v, int position, + long id) { + onListItemClick((ListView) parent, v, position, id); + } + }; @Implementation public void onViewCreated(View view, Bundle savedInstanceState) { diff --git a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/AbstractActivityTest.java b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/AbstractActivityTest.java index 2ba646a3b1..a099aa3318 100644 --- a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/AbstractActivityTest.java +++ b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/AbstractActivityTest.java @@ -31,5 +31,5 @@ public void activityShouldBeFinal() { assertThat(Modifier.isFinal(modifiers)).isTrue(); } - + } diff --git a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/AndroidAnnotationsTestRunner.java b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/AndroidAnnotationsTestRunner.java index 84a0372c8f..0005ef2e92 100644 --- a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/AndroidAnnotationsTestRunner.java +++ b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/AndroidAnnotationsTestRunner.java @@ -22,7 +22,8 @@ import com.xtremelabs.robolectric.RobolectricTestRunner; public class AndroidAnnotationsTestRunner extends RobolectricTestRunner { - public AndroidAnnotationsTestRunner(Class testClass) throws InitializationError { - super(testClass, new File("../functional-test-1-5")); - } + public AndroidAnnotationsTestRunner(Class testClass) + throws InitializationError { + super(testClass, new File("../functional-test-1-5")); + } } diff --git a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ApplicationInjectedActivityTest.java b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ApplicationInjectedActivityTest.java index 4ab3ae8d15..74018ebf27 100644 --- a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ApplicationInjectedActivityTest.java +++ b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ApplicationInjectedActivityTest.java @@ -24,29 +24,28 @@ @RunWith(AndroidAnnotationsTestRunner.class) public class ApplicationInjectedActivityTest { - + @Test public void should_have_application_after_create() { new SampleRoboApplication_().onCreate(); ApplicationInjectedActivity_ activity = new ApplicationInjectedActivity_(); - + activity.onCreate(null); assertThat(activity.customApplication).isNotNull(); } - + @Test public void application_can_be_replaced_for_tests() { SampleRoboApplication testApp = new SampleRoboApplication(); - + SampleRoboApplication_.setForTesting(testApp); - + ApplicationInjectedActivity_ activity = new ApplicationInjectedActivity_(); - + activity.onCreate(null); assertThat(activity.customApplication).isSameAs(testApp); } - } diff --git a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/AwaitingResultActivityTest.java b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/AwaitingResultActivityTest.java index fceb878963..22e629feac 100644 --- a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/AwaitingResultActivityTest.java +++ b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/AwaitingResultActivityTest.java @@ -28,41 +28,46 @@ public void onlyFirstRequestAnnotatedMethodAreCalled() { AwaitingResultActivity_ activity = new AwaitingResultActivity_(); activity.onActivityResult(AwaitingResultActivity.FIRST_REQUEST, 0, null); - + assertThat(activity.onResultCalled).isTrue(); assertThat(activity.onResultWithDataCalled).isFalse(); - assertThat(activity.onActivityResultWithResultCodeAndDataCalled).isFalse(); - assertThat(activity.onActivityResultWithDataAndResultCodeCalled).isFalse(); + assertThat(activity.onActivityResultWithResultCodeAndDataCalled) + .isFalse(); + assertThat(activity.onActivityResultWithDataAndResultCodeCalled) + .isFalse(); assertThat(activity.onResultWithIntResultCodeCalled).isFalse(); assertThat(activity.onResultWithIntegerResultCodeCalled).isFalse(); } - @Test public void onlySecondRequestAnnotatedMethodAreCalled() { AwaitingResultActivity_ activity = new AwaitingResultActivity_(); - activity.onActivityResult(AwaitingResultActivity.SECOND_REQUEST, 0, null); - + activity.onActivityResult(AwaitingResultActivity.SECOND_REQUEST, 0, + null); + assertThat(activity.onResultCalled).isFalse(); assertThat(activity.onResultWithDataCalled).isTrue(); - assertThat(activity.onActivityResultWithResultCodeAndDataCalled).isTrue(); - assertThat(activity.onActivityResultWithDataAndResultCodeCalled).isTrue(); + assertThat(activity.onActivityResultWithResultCodeAndDataCalled) + .isTrue(); + assertThat(activity.onActivityResultWithDataAndResultCodeCalled) + .isTrue(); assertThat(activity.onResultWithIntResultCodeCalled).isFalse(); assertThat(activity.onResultWithIntegerResultCodeCalled).isFalse(); } - @Test public void onlyThirdRequestAnnotatedMethodAreCalled() { AwaitingResultActivity_ activity = new AwaitingResultActivity_(); activity.onActivityResult(AwaitingResultActivity.THIRD_REQUEST, 0, null); - + assertThat(activity.onResultCalled).isFalse(); assertThat(activity.onResultWithDataCalled).isFalse(); - assertThat(activity.onActivityResultWithResultCodeAndDataCalled).isFalse(); - assertThat(activity.onActivityResultWithDataAndResultCodeCalled).isFalse(); + assertThat(activity.onActivityResultWithResultCodeAndDataCalled) + .isFalse(); + assertThat(activity.onActivityResultWithDataAndResultCodeCalled) + .isFalse(); assertThat(activity.onResultWithIntResultCodeCalled).isTrue(); assertThat(activity.onResultWithIntegerResultCodeCalled).isTrue(); } diff --git a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ClicksHandledActivityTest.java b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ClicksHandledActivityTest.java index 3ba56c9a00..1454c9c947 100644 --- a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ClicksHandledActivityTest.java +++ b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ClicksHandledActivityTest.java @@ -50,43 +50,44 @@ public void avoidStackOverflow() { @Test public void handlingWithConvention() { assertThat(activity.conventionButtonEventHandled).isFalse(); - + activity.findViewById(R.id.conventionButton).performClick(); - + assertThat(activity.conventionButtonEventHandled).isTrue(); } @Test public void handlingWithSnakeCase() { assertThat(activity.snakeCaseButtonEventHandled).isFalse(); - + activity.findViewById(R.id.snake_case_button).performClick(); - + assertThat(activity.snakeCaseButtonEventHandled).isTrue(); } @Test public void handlingWithExtendedConvention() { assertThat(activity.extendedConventionButtonEventHandled).isFalse(); - + activity.findViewById(R.id.extendedConventionButton).performClick(); - + assertThat(activity.extendedConventionButtonEventHandled).isTrue(); } @Test public void handlingWithConfigurationOverConvention() { assertThat(activity.overridenConventionButtonEventHandled).isFalse(); - - activity.findViewById(R.id.configurationOverConventionButton).performClick(); - + + activity.findViewById(R.id.configurationOverConventionButton) + .performClick(); + assertThat(activity.overridenConventionButtonEventHandled).isTrue(); } @Test public void unannotatedButtonIsNotHandled() { activity.findViewById(R.id.unboundButton).performClick(); - + assertThat(activity.unboundButtonEventHandled).isFalse(); } @@ -103,26 +104,26 @@ public void viewArgumentIsGiven() { public void multipleButtonsClicked() { assertThat(activity.multipleButtonsEventHandled).isFalse(); - activity.findViewById(R.id.button1).performClick(); + activity.findViewById(R.id.button1).performClick(); assertThat(activity.multipleButtonsEventHandled).isTrue(); assertThat(activity.viewArgument).hasId(R.id.button1); - + activity.multipleButtonsEventHandled = false; - + activity.findViewById(R.id.button2).performClick(); assertThat(activity.multipleButtonsEventHandled).isTrue(); assertThat(activity.viewArgument).hasId(R.id.button2); } - + @Test public void libResBussonClicked() { assertThat(activity.libResButtonEventHandled).isFalse(); - activity.findViewById(R.id.libResButton1).performClick(); + activity.findViewById(R.id.libResButton1).performClick(); assertThat(activity.libResButtonEventHandled).isTrue(); - + activity.libResButtonEventHandled = false; - + activity.findViewById(R.id.libResButton2).performClick(); assertThat(activity.libResButtonEventHandled).isTrue(); } diff --git a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/EmptyActivityWithLayoutTest.java b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/EmptyActivityWithLayoutTest.java index 54a97a04f5..3a1b836f3e 100644 --- a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/EmptyActivityWithLayoutTest.java +++ b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/EmptyActivityWithLayoutTest.java @@ -31,7 +31,8 @@ public void shouldHaveLayoutAfterCreate() { activity.onCreate(null); - assertThat(activity.findViewById(R.id.helloTextView)).hasId(R.id.helloTextView); + assertThat(activity.findViewById(R.id.helloTextView)).hasId( + R.id.helloTextView); } } diff --git a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/FakeClipboardManager.java b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/FakeClipboardManager.java index 38779b9d7a..a80670a90a 100644 --- a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/FakeClipboardManager.java +++ b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/FakeClipboardManager.java @@ -17,9 +17,7 @@ import android.text.ClipboardManager; -import com.xtremelabs.robolectric.internal.Implementation; -import com.xtremelabs.robolectric.internal.Implements; - +@SuppressWarnings("deprecation") public class FakeClipboardManager extends ClipboardManager { private CharSequence text; diff --git a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/FromHtmlActivityTest.java b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/FromHtmlActivityTest.java index b1d64c1311..73296478dd 100644 --- a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/FromHtmlActivityTest.java +++ b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/FromHtmlActivityTest.java @@ -43,12 +43,14 @@ public void setup() { @Test public void injectionOfHtmlTest() { assertNotNull(activity.textView); - assertEquals(Html.fromHtml(activity.getString(R.string.hello_html)), activity.textView.getText()); + assertEquals(Html.fromHtml(activity.getString(R.string.hello_html)), + activity.textView.getText()); } @Test public void injectionOfHtmlWithDefaultName() { assertNotNull(activity.someView); - assertEquals(Html.fromHtml(activity.getString(R.string.someView)), activity.someView.getText()); + assertEquals(Html.fromHtml(activity.getString(R.string.someView)), + activity.someView.getText()); } } diff --git a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/InjectExtraTest.java b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/InjectExtraTest.java index 25e6c56dbe..74884fd277 100644 --- a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/InjectExtraTest.java +++ b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/InjectExtraTest.java @@ -89,7 +89,7 @@ public void setIntent_reinjects_extra() { assertThat(activity.stringExtra).isEqualTo("Hello Again!"); } - + @Test public void extraWithoutValueInjected() { intent.putExtra("extraWithoutValue", "Hello!"); diff --git a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ItemClicksHandledActivityTest.java b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ItemClicksHandledActivityTest.java index 262a11fc44..a275236f9b 100644 --- a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ItemClicksHandledActivityTest.java +++ b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ItemClicksHandledActivityTest.java @@ -38,7 +38,8 @@ public class ItemClicksHandledActivityTest { public void setup() { activity = new ItemClicksHandledActivity_(); activity.onCreate(null); - clickedItem = activity.getResources().getStringArray(R.array.planets_array)[TESTED_CLICKED_INDEX]; + clickedItem = activity.getResources().getStringArray( + R.array.planets_array)[TESTED_CLICKED_INDEX]; } @Test @@ -65,53 +66,63 @@ public void handlingListViewItemClick() { @Test public void handlingSpinnerItemClickWithArgument() { - Spinner spinner = (Spinner) activity.findViewById(R.id.spinnerWithArgument); + Spinner spinner = (Spinner) activity + .findViewById(R.id.spinnerWithArgument); long itemId = spinner.getAdapter().getItemId(TESTED_CLICKED_INDEX); View view = spinner.getChildAt(TESTED_CLICKED_INDEX); assertThat(activity.spinnerWithArgumentSelectedItem).isNull(); spinner.performItemClick(view, TESTED_CLICKED_INDEX, itemId); assertThat(activity.spinnerWithArgumentSelectedItem).isNotNull(); - assertThat(activity.spinnerWithArgumentSelectedItem).isEqualTo(clickedItem); + assertThat(activity.spinnerWithArgumentSelectedItem).isEqualTo( + clickedItem); } @Test public void handlingListViewitemClickWithArgument() { - ListView listView = (ListView) activity.findViewById(R.id.listViewWithArgument); + ListView listView = (ListView) activity + .findViewById(R.id.listViewWithArgument); long itemId = listView.getAdapter().getItemId(TESTED_CLICKED_INDEX); View view = listView.getChildAt(TESTED_CLICKED_INDEX); assertThat(activity.listViewWithArgumentSelectedItem).isNull(); listView.performItemClick(view, TESTED_CLICKED_INDEX, itemId); assertThat(activity.listViewWithArgumentSelectedItem).isNotNull(); - assertThat(activity.listViewWithArgumentSelectedItem).isEqualTo(clickedItem); + assertThat(activity.listViewWithArgumentSelectedItem).isEqualTo( + clickedItem); } @Test public void handlingListViewItemClickWithPosition() { - ListView listView = (ListView) activity.findViewById(R.id.listViewWithPosition); + ListView listView = (ListView) activity + .findViewById(R.id.listViewWithPosition); long itemId = listView.getAdapter().getItemId(TESTED_CLICKED_INDEX); View view = listView.getChildAt(TESTED_CLICKED_INDEX); assertThat(activity.listViewWithPositionClickedPosition).isEqualTo(0); listView.performItemClick(view, TESTED_CLICKED_INDEX, itemId); - assertThat(activity.listViewWithPositionClickedPosition).isEqualTo(TESTED_CLICKED_INDEX); + assertThat(activity.listViewWithPositionClickedPosition).isEqualTo( + TESTED_CLICKED_INDEX); } @Test public void handlingListViewWithPositionItemSelected() { - ListView listView = (ListView) activity.findViewById(R.id.listViewWithPosition); + ListView listView = (ListView) activity + .findViewById(R.id.listViewWithPosition); - assertThat(activity.listViewWithPositionItemSelectedPosition).isEqualTo(0); + assertThat(activity.listViewWithPositionItemSelectedPosition) + .isEqualTo(0); assertThat(activity.listViewWithPositionItemSelected).isFalse(); listView.setSelection(TESTED_CLICKED_INDEX); assertThat(activity.listViewWithPositionItemSelected).isTrue(); - assertThat(activity.listViewWithPositionItemSelectedPosition).isEqualTo(TESTED_CLICKED_INDEX); + assertThat(activity.listViewWithPositionItemSelectedPosition) + .isEqualTo(TESTED_CLICKED_INDEX); } - + @Test public void can_have_one_selected_argument() { - ListView listView = (ListView) activity.findViewById(R.id.listViewWithOneParam); + ListView listView = (ListView) activity + .findViewById(R.id.listViewWithOneParam); assertThat(activity.listViewWithOneParamItemSelected).isFalse(); listView.setSelection(TESTED_CLICKED_INDEX); assertThat(activity.listViewWithOneParamItemSelected).isTrue(); diff --git a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/LongClicksHandledActivityTest.java b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/LongClicksHandledActivityTest.java index 36d043563e..78abfe0a06 100644 --- a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/LongClicksHandledActivityTest.java +++ b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/LongClicksHandledActivityTest.java @@ -78,7 +78,8 @@ public void handlingWithExtendedConvention() { public void handlingWithConfigurationOverConvention() { assertThat(activity.overridenConventionButtonEventHandled).isFalse(); - activity.findViewById(R.id.configurationOverConventionButton).performLongClick(); + activity.findViewById(R.id.configurationOverConventionButton) + .performLongClick(); assertThat(activity.overridenConventionButtonEventHandled).isTrue(); } diff --git a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/RobolectricParameterized.java b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/RobolectricParameterized.java index b5cc656018..375f98af5b 100644 --- a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/RobolectricParameterized.java +++ b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/RobolectricParameterized.java @@ -64,7 +64,10 @@ * public class FibonacciTest { * @Parameters * public static List<Object[]> data() { - * return Arrays.asList(new Object[][] { Fibonacci, { { 0, 0 }, { 1, 1 }, { 2, 1 }, { 3, 2 }, { 4, 3 }, { 5, 5 }, { 6, 8 } } }); + * return Arrays.asList(new Object[][] { + * Fibonacci, + * { { 0, 0 }, { 1, 1 }, { 2, 1 }, { 3, 2 }, { 4, 3 }, { 5, 5 }, + * { 6, 8 } } }); * } * * private int fInput; @@ -91,18 +94,21 @@ */ public class RobolectricParameterized extends Suite { - public static class TestClassRunnerForParameters extends AndroidAnnotationsTestRunner { + public static class TestClassRunnerForParameters extends + AndroidAnnotationsTestRunner { private int parameterSetNumber; private List parameterList; private RobolectricParameterized motherRunner; - public TestClassRunnerForParameters(Class type) throws InitializationError { + public TestClassRunnerForParameters(Class type) + throws InitializationError { super(type); } - private void init(RobolectricParameterized motherRunner, List parameterList, int parameterSetNumber) { + private void init(RobolectricParameterized motherRunner, + List parameterList, int parameterSetNumber) { this.motherRunner = motherRunner; this.parameterList = parameterList; this.parameterSetNumber = parameterSetNumber; @@ -144,7 +150,8 @@ public Object createTest() throws Exception { } if (initMethod == null) { - throw new RuntimeException("No init method found in parameterized test"); + throw new RuntimeException( + "No init method found in parameterized test"); } initMethod.setAccessible(true); @@ -160,7 +167,10 @@ private Object[] computeParams() throws Exception { try { return parameterList.get(parameterSetNumber); } catch (ClassCastException e) { - throw new Exception(String.format("%s.%s() must return a Collection of arrays.", getTestClass().getName(), motherRunner.getParametersMethod(getTestClass()).getName())); + throw new Exception(String.format( + "%s.%s() must return a Collection of arrays.", + getTestClass().getName(), motherRunner + .getParametersMethod(getTestClass()).getName())); } } @@ -171,7 +181,8 @@ protected String getName() { @Override protected String testName(final FrameworkMethod method) { - return String.format("%s[%s]", method.getName(), parameterSetNumber); + return String + .format("%s[%s]", method.getName(), parameterSetNumber); } @Override @@ -197,7 +208,8 @@ public RobolectricParameterized(Class klass) throws Throwable { super(robolectricClass(klass), Collections. emptyList()); List parametersList = getParametersList(getTestClass()); for (int i = 0; i < parametersList.size(); i++) { - TestClassRunnerForParameters testRunner = new TestClassRunnerForParameters(getTestClass().getJavaClass()); + TestClassRunnerForParameters testRunner = new TestClassRunnerForParameters( + getTestClass().getJavaClass()); testRunner.init(this, parametersList, i); runners.add(testRunner); } @@ -210,26 +222,33 @@ protected List getChildren() { @SuppressWarnings("unchecked") private List getParametersList(TestClass klass) throws Throwable { - return (List) getParametersMethod(klass).invokeExplosively(null); + return (List) getParametersMethod(klass).invokeExplosively( + null); } - private FrameworkMethod getParametersMethod(TestClass testClass) throws Exception { - List methods = testClass.getAnnotatedMethods(Parameters.class); + private FrameworkMethod getParametersMethod(TestClass testClass) + throws Exception { + List methods = testClass + .getAnnotatedMethods(Parameters.class); for (FrameworkMethod each : methods) { int modifiers = each.getMethod().getModifiers(); if (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers)) return each; } - throw new Exception("No public static parameters method on class " + testClass.getName()); + throw new Exception("No public static parameters method on class " + + testClass.getName()); } - private static Class robolectricClass(Class originalClass) throws Exception { + private static Class robolectricClass(Class originalClass) + throws Exception { return getRobolectricLoader().loadClass(originalClass.getName()); } - private static RobolectricClassLoader getRobolectricLoader() throws Exception { - Method getDefaultLoader = RobolectricTestRunner.class.getDeclaredMethod("getDefaultLoader"); + private static RobolectricClassLoader getRobolectricLoader() + throws Exception { + Method getDefaultLoader = RobolectricTestRunner.class + .getDeclaredMethod("getDefaultLoader"); getDefaultLoader.setAccessible(true); return (RobolectricClassLoader) getDefaultLoader.invoke(null); } diff --git a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/SSLConnectionTest.java b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/SSLConnectionTest.java index b4e2e355a0..8c66448e69 100644 --- a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/SSLConnectionTest.java +++ b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/SSLConnectionTest.java @@ -51,7 +51,8 @@ public void setup() { @Test public void truststoreProvided() { assertNotNull(activity.mHttpsClientTest1); - ClientConnectionManager ccm = activity.mHttpsClientTest1.getConnectionManager(); + ClientConnectionManager ccm = activity.mHttpsClientTest1 + .getConnectionManager(); assertNotNull(ccm); Scheme httpsScheme = ccm.getSchemeRegistry().getScheme("https"); @@ -61,25 +62,31 @@ public void truststoreProvided() { SocketFactory socketFactHttps = httpsScheme.getSocketFactory(); if (!(socketFactHttps instanceof SSLSocketFactory)) { - Assert.fail("wrong instance should be org.apache.http.conn.ssl.SSLSocketFactory, getting " + socketFactHttps); + Assert.fail("wrong instance should be org.apache.http.conn.ssl.SSLSocketFactory, getting " + + socketFactHttps); } - assertEquals(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER, ((SSLSocketFactory) socketFactHttps).getHostnameVerifier()); + assertEquals(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER, + ((SSLSocketFactory) socketFactHttps).getHostnameVerifier()); } @Test public void strictHostnameVerifier() { assertNotNull(activity.mHttpsClientTest2); - ClientConnectionManager ccm = activity.mHttpsClientTest2.getConnectionManager(); + ClientConnectionManager ccm = activity.mHttpsClientTest2 + .getConnectionManager(); Scheme httpsScheme = ccm.getSchemeRegistry().getScheme("https"); - SSLSocketFactory socketFactHttps = (SSLSocketFactory) httpsScheme.getSocketFactory(); + SSLSocketFactory socketFactHttps = (SSLSocketFactory) httpsScheme + .getSocketFactory(); - assertEquals(SSLSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER, ((SSLSocketFactory) socketFactHttps).getHostnameVerifier()); + assertEquals(SSLSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER, + ((SSLSocketFactory) socketFactHttps).getHostnameVerifier()); } @Test public void noOptions() { assertNotNull(activity.mHttpsClientTest3); - ClientConnectionManager ccm = activity.mHttpsClientTest3.getConnectionManager(); + ClientConnectionManager ccm = activity.mHttpsClientTest3 + .getConnectionManager(); assertNotNull(ccm); } } diff --git a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ServiceInjectionTest.java b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ServiceInjectionTest.java index 04acd26402..20cf8ee8b4 100644 --- a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ServiceInjectionTest.java +++ b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ServiceInjectionTest.java @@ -33,12 +33,15 @@ public class ServiceInjectionTest { @Before public void setup() throws Exception { - Field serviceMapField = ShadowApplication.class.getDeclaredField("SYSTEM_SERVICE_MAP"); + Field serviceMapField = ShadowApplication.class + .getDeclaredField("SYSTEM_SERVICE_MAP"); serviceMapField.setAccessible(true); @SuppressWarnings("unchecked") - Map SYSTEM_SERVICE_MAP = (Map) serviceMapField.get(null); + Map SYSTEM_SERVICE_MAP = (Map) serviceMapField + .get(null); - SYSTEM_SERVICE_MAP.put(Context.CLIPBOARD_SERVICE, "org.androidannotations.test15.FakeClipboardManager"); + SYSTEM_SERVICE_MAP.put(Context.CLIPBOARD_SERVICE, + "org.androidannotations.test15.FakeClipboardManager"); } @Test diff --git a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ThreadActivityTest.java b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ThreadActivityTest.java index 23c53fe4ce..8b5b24ef91 100644 --- a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ThreadActivityTest.java +++ b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ThreadActivityTest.java @@ -21,13 +21,12 @@ import java.util.concurrent.Executor; +import org.androidannotations.api.BackgroundExecutor; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mockito; -import org.androidannotations.api.BackgroundExecutor; - @RunWith(AndroidAnnotationsTestRunner.class) public class ThreadActivityTest { @@ -41,14 +40,14 @@ public void setup() { @Test public void backgroundDelegatesToExecutor() { - + Executor executor = mock(Executor.class); - + BackgroundExecutor.setExecutor(executor); - + activity.emptyBackgroundMethod(); - - verify(executor).execute(Mockito.any()); + + verify(executor).execute(Mockito. any()); } } diff --git a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/TouchesHandledActivityTest.java b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/TouchesHandledActivityTest.java index 48cba63392..b50cb368f2 100644 --- a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/TouchesHandledActivityTest.java +++ b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/TouchesHandledActivityTest.java @@ -43,7 +43,8 @@ public void setup() { public void handlingWithConvention() { assertThat(activity.conventionButtonEventHandled).isFalse(); - activity.findViewById(R.id.conventionButton).dispatchTouchEvent(mockedEvent); + activity.findViewById(R.id.conventionButton).dispatchTouchEvent( + mockedEvent); assertThat(activity.conventionButtonEventHandled).isTrue(); } @@ -52,7 +53,8 @@ public void handlingWithConvention() { public void handlingWithSnakeCase() { assertThat(activity.snakeCaseButtonEventHandled).isFalse(); - activity.findViewById(R.id.snake_case_button).dispatchTouchEvent(mockedEvent); + activity.findViewById(R.id.snake_case_button).dispatchTouchEvent( + mockedEvent); assertThat(activity.snakeCaseButtonEventHandled).isTrue(); } @@ -61,7 +63,8 @@ public void handlingWithSnakeCase() { public void handlingWithExtendedConvention() { assertThat(activity.extendedConventionButtonEventHandled).isFalse(); - activity.findViewById(R.id.extendedConventionButton).dispatchTouchEvent(mockedEvent); + activity.findViewById(R.id.extendedConventionButton) + .dispatchTouchEvent(mockedEvent); assertThat(activity.extendedConventionButtonEventHandled).isTrue(); } @@ -70,14 +73,16 @@ public void handlingWithExtendedConvention() { public void handlingWithConfigurationOverConvention() { assertThat(activity.overridenConventionButtonEventHandled).isFalse(); - activity.findViewById(R.id.configurationOverConventionButton).dispatchTouchEvent(mockedEvent); + activity.findViewById(R.id.configurationOverConventionButton) + .dispatchTouchEvent(mockedEvent); assertThat(activity.overridenConventionButtonEventHandled).isTrue(); } @Test public void unannotatedButtonIsNotHandled() { - activity.findViewById(R.id.unboundButton).dispatchTouchEvent(mockedEvent); + activity.findViewById(R.id.unboundButton).dispatchTouchEvent( + mockedEvent); assertThat(activity.unboundButtonEventHandled).isFalse(); } @@ -86,7 +91,8 @@ public void unannotatedButtonIsNotHandled() { public void viewArgumentIsGiven() { assertThat(activity.viewArgument).isNull(); - activity.findViewById(R.id.buttonWithViewArgument).dispatchTouchEvent(mockedEvent); + activity.findViewById(R.id.buttonWithViewArgument).dispatchTouchEvent( + mockedEvent); assertThat(activity.viewArgument).hasId(R.id.buttonWithViewArgument); } diff --git a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/TracedActivityTest.java b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/TracedActivityTest.java index b841ce072d..0595aec40a 100644 --- a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/TracedActivityTest.java +++ b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/TracedActivityTest.java @@ -25,47 +25,46 @@ @RunWith(AndroidAnnotationsTestRunner.class) public class TracedActivityTest { - @Test - public void servicesAreInjected() throws IOException { - TracedActivity_ activity = new TracedActivity_(); - activity.onCreate(null); - - assertThat(activity.tracedMethodCalled).isFalse(); - activity.tracedMethod(null, null); - assertThat(activity.tracedMethodCalled).isTrue(); + @Test + public void servicesAreInjected() throws IOException { + TracedActivity_ activity = new TracedActivity_(); + activity.onCreate(null); - assertThat(activity.voidTracedMethodCalled).isFalse(); - activity.voidTracedMethod(null, null); - assertThat(activity.voidTracedMethodCalled).isTrue(); + assertThat(activity.tracedMethodCalled).isFalse(); + activity.tracedMethod(null, null); + assertThat(activity.tracedMethodCalled).isTrue(); - assertThat(activity.voidTracedMethodDebugCalled).isFalse(); - activity.voidTracedMethodDebug(); - assertThat(activity.voidTracedMethodDebugCalled).isTrue(); + assertThat(activity.voidTracedMethodCalled).isFalse(); + activity.voidTracedMethod(null, null); + assertThat(activity.voidTracedMethodCalled).isTrue(); - assertThat(activity.voidTracedMethodErrorCalled).isFalse(); - activity.voidTracedMethodError(); - assertThat(activity.voidTracedMethodErrorCalled).isTrue(); + assertThat(activity.voidTracedMethodDebugCalled).isFalse(); + activity.voidTracedMethodDebug(); + assertThat(activity.voidTracedMethodDebugCalled).isTrue(); - assertThat(activity.voidTracedMethodInfoCalled).isFalse(); - activity.voidTracedMethodInfo(); - assertThat(activity.voidTracedMethodInfoCalled).isTrue(); + assertThat(activity.voidTracedMethodErrorCalled).isFalse(); + activity.voidTracedMethodError(); + assertThat(activity.voidTracedMethodErrorCalled).isTrue(); - assertThat(activity.voidTracedMethodVerboseCalled).isFalse(); - activity.voidTracedMethodVerbose(); - assertThat(activity.voidTracedMethodVerboseCalled).isTrue(); + assertThat(activity.voidTracedMethodInfoCalled).isFalse(); + activity.voidTracedMethodInfo(); + assertThat(activity.voidTracedMethodInfoCalled).isTrue(); - assertThat(activity.voidTracedMethodWarnCalled).isFalse(); - activity.voidTracedMethodWarn(); - assertThat(activity.voidTracedMethodWarnCalled).isTrue(); + assertThat(activity.voidTracedMethodVerboseCalled).isFalse(); + activity.voidTracedMethodVerbose(); + assertThat(activity.voidTracedMethodVerboseCalled).isTrue(); - assertThat(activity.overloadedMethodInt).isFalse(); - activity.overloadedMethod(0); - assertThat(activity.overloadedMethodInt).isTrue(); + assertThat(activity.voidTracedMethodWarnCalled).isFalse(); + activity.voidTracedMethodWarn(); + assertThat(activity.voidTracedMethodWarnCalled).isTrue(); + + assertThat(activity.overloadedMethodInt).isFalse(); + activity.overloadedMethod(0); + assertThat(activity.overloadedMethodInt).isTrue(); + + assertThat(activity.overloadedMethodIntFLoat).isFalse(); + activity.overloadedMethod(0, 0f); + assertThat(activity.overloadedMethodIntFLoat).isTrue(); + } - assertThat(activity.overloadedMethodIntFLoat).isFalse(); - activity.overloadedMethod(0, 0f); - assertThat(activity.overloadedMethodIntFLoat).isTrue(); - } - - } diff --git a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ViewAssert.java b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ViewAssert.java index 3ee69474bb..217a39a960 100644 --- a/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ViewAssert.java +++ b/AndroidAnnotations/functional-test-1-5-tests/src/test/java/org/androidannotations/test15/ViewAssert.java @@ -36,7 +36,8 @@ public ViewAssert hasId(int id) { } failIfCustomMessageIsSet(); - throw failure(concat("view id is ", inBrackets(actual.getId()), ", should be ", inBrackets(id))); + throw failure(concat("view id is ", inBrackets(actual.getId()), + ", should be ", inBrackets(id))); } } diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/AbstractActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/AbstractActivity.java index 3a4a462b76..c1de952cb8 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/AbstractActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/AbstractActivity.java @@ -15,12 +15,12 @@ */ package org.androidannotations.test15; -import android.app.Activity; -import android.widget.Button; - import org.androidannotations.annotations.EActivity; import org.androidannotations.annotations.ViewById; +import android.app.Activity; +import android.widget.Button; + @EActivity(R.layout.views_injected) public abstract class AbstractActivity extends Activity { diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ActivityWithServices.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ActivityWithServices.java index 14d8bdd842..c419de1035 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ActivityWithServices.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ActivityWithServices.java @@ -15,6 +15,9 @@ */ package org.androidannotations.test15; +import org.androidannotations.annotations.EActivity; +import org.androidannotations.annotations.SystemService; + import android.app.Activity; import android.app.ActivityManager; import android.app.AlarmManager; @@ -34,9 +37,7 @@ import android.view.WindowManager; import android.view.inputmethod.InputMethodManager; -import org.androidannotations.annotations.EActivity; -import org.androidannotations.annotations.SystemService; - +@SuppressWarnings("deprecation") @EActivity public class ActivityWithServices extends Activity { @@ -76,7 +77,6 @@ public class ActivityWithServices extends Activity { @SystemService WifiManager wifiManager; - @SystemService InputMethodManager inputMethodManager; diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ApplicationInjectedActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ApplicationInjectedActivity.java index 7b4c001ef4..970397ae51 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ApplicationInjectedActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ApplicationInjectedActivity.java @@ -15,12 +15,12 @@ */ package org.androidannotations.test15; -import android.app.Activity; - import org.androidannotations.annotations.App; import org.androidannotations.annotations.EActivity; import org.androidannotations.test15.roboguice.SampleRoboApplication; +import android.app.Activity; + @EActivity public class ApplicationInjectedActivity extends Activity { diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/AwaitingResultActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/AwaitingResultActivity.java index f80fd8a298..131035b5c7 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/AwaitingResultActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/AwaitingResultActivity.java @@ -15,12 +15,12 @@ */ package org.androidannotations.test15; -import android.app.Activity; -import android.content.Intent; - import org.androidannotations.annotations.EActivity; import org.androidannotations.annotations.OnActivityResult; +import android.app.Activity; +import android.content.Intent; + @EActivity(R.layout.views_injected) public class AwaitingResultActivity extends Activity { @@ -28,12 +28,12 @@ public class AwaitingResultActivity extends Activity { static final int SECOND_REQUEST = 22; static final int THIRD_REQUEST = 33; - boolean onResultCalled = false; - boolean onResultWithDataCalled = false; - boolean onActivityResultWithResultCodeAndDataCalled = false; - boolean onActivityResultWithDataAndResultCodeCalled = false; - boolean onResultWithIntResultCodeCalled = false; - boolean onResultWithIntegerResultCodeCalled = false; + boolean onResultCalled = false; + boolean onResultWithDataCalled = false; + boolean onActivityResultWithResultCodeAndDataCalled = false; + boolean onActivityResultWithDataAndResultCodeCalled = false; + boolean onResultWithIntResultCodeCalled = false; + boolean onResultWithIntegerResultCodeCalled = false; @OnActivityResult(FIRST_REQUEST) void onResult() { diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/BackpressedActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/BackpressedActivity.java index d88383ff1d..fa0eedc5b3 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/BackpressedActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/BackpressedActivity.java @@ -15,10 +15,10 @@ */ package org.androidannotations.test15; -import android.app.Activity; - import org.androidannotations.annotations.EActivity; +import android.app.Activity; + @EActivity(R.layout.main) public class BackpressedActivity extends Activity { 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 index 6f7880586c..3a873e3b9a 100644 --- 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 @@ -49,7 +49,8 @@ public void buttonWithViewArgument() { } @CheckedChange({ R.id.button1, R.id.button2 }) - public void multipleButtonWithViewArgument(CompoundButton v, boolean hasFocus) { + public void multipleButtonWithViewArgument(CompoundButton v, + boolean hasFocus) { } diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ClicksHandledActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ClicksHandledActivity.java index b3d4e7b835..7357bae8d0 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ClicksHandledActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ClicksHandledActivity.java @@ -15,11 +15,11 @@ */ package org.androidannotations.test15; -import android.view.View; - import org.androidannotations.annotations.Click; import org.androidannotations.annotations.EActivity; +import android.view.View; + @EActivity(R.layout.clickable_widgets) public class ClicksHandledActivity extends EventsHandledAbstractActivity { @@ -27,8 +27,8 @@ public class ClicksHandledActivity extends EventsHandledAbstractActivity { public void onClick(View v) { avoidStackOverflowEventHandled = true; } - - @Click(resName={"libResButton1", "libResButton2"}) + + @Click(resName = { "libResButton1", "libResButton2" }) public void libResButton() { libResButtonEventHandled = true; } diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/CustomTitleActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/CustomTitleActivity.java index f719ed44b8..4b3b9bffbe 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/CustomTitleActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/CustomTitleActivity.java @@ -15,10 +15,10 @@ */ package org.androidannotations.test15; -import android.app.Activity; - -import org.androidannotations.annotations.EActivity; import org.androidannotations.annotations.CustomTitle; +import org.androidannotations.annotations.EActivity; + +import android.app.Activity; @EActivity @CustomTitle(R.layout.component) diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/EmptyActivityWithLayout.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/EmptyActivityWithLayout.java index 4a5f534fa2..ad8b40911a 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/EmptyActivityWithLayout.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/EmptyActivityWithLayout.java @@ -15,10 +15,10 @@ */ package org.androidannotations.test15; -import android.app.Activity; - import org.androidannotations.annotations.EActivity; +import android.app.Activity; + @EActivity(R.layout.main) public class EmptyActivityWithLayout extends Activity { } diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/EmptyActivityWithoutLayout.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/EmptyActivityWithoutLayout.java index 9c56b59e18..82220bcac1 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/EmptyActivityWithoutLayout.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/EmptyActivityWithoutLayout.java @@ -15,10 +15,10 @@ */ package org.androidannotations.test15; -import android.app.Activity; +import org.androidannotations.annotations.EActivity; +import android.app.Activity; import android.os.Bundle; -import org.androidannotations.annotations.EActivity; @EActivity public class EmptyActivityWithoutLayout extends Activity { diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ExtendingActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ExtendingActivity.java index d7c5497617..2ff77daa38 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ExtendingActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ExtendingActivity.java @@ -19,5 +19,5 @@ @EActivity public class ExtendingActivity extends AbstractActivity { - + } diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ExtraInjectedActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ExtraInjectedActivity.java index f789e052ec..3ee1e872fe 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ExtraInjectedActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ExtraInjectedActivity.java @@ -17,12 +17,12 @@ import java.util.List; -import android.app.Activity; -import android.content.Intent; - import org.androidannotations.annotations.EActivity; import org.androidannotations.annotations.Extra; +import android.app.Activity; +import android.content.Intent; + @EActivity public class ExtraInjectedActivity extends Activity { @@ -43,7 +43,7 @@ public class ExtraInjectedActivity extends Activity { @Extra String extraWithoutValue; - + @Extra ParcelableSerializableData parcelableSerializableData; @@ -55,7 +55,10 @@ protected void onNewIntent(Intent intent) { void intentWithExtras() { ExtraInjectedActivity_.intent(this).arrayExtra(null).start(); ExtraInjectedActivity_.intent(this).intExtra(42).get(); - ExtraInjectedActivity_.intent(this).stringExtra("hello").startForResult(42); - ExtraInjectedActivity_.intent(this).parcelableSerializableData(new ParcelableSerializableData()).get(); + ExtraInjectedActivity_.intent(this).stringExtra("hello") + .startForResult(42); + ExtraInjectedActivity_.intent(this) + .parcelableSerializableData(new ParcelableSerializableData()) + .get(); } } diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/FragmentArguments.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/FragmentArguments.java index 31091768fc..ece3b131cf 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/FragmentArguments.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/FragmentArguments.java @@ -17,9 +17,6 @@ import java.util.ArrayList; -import android.app.Fragment; -import android.os.Bundle; - import org.androidannotations.annotations.AfterInject; import org.androidannotations.annotations.EFragment; import org.androidannotations.annotations.FragmentArg; @@ -28,6 +25,9 @@ import org.androidannotations.test15.instancestate.MyParcelableBean; import org.androidannotations.test15.instancestate.MySerializableBean; +import android.app.Fragment; +import android.os.Bundle; + @EFragment public class FragmentArguments extends Fragment { @@ -171,14 +171,15 @@ public class FragmentArguments extends Fragment { @FragmentArg MyGenericParcelableBean[] myGenericParcelableBeanArray; - + @AfterInject - void afterInject(){ - + void afterInject() { + } static { - FragmentArguments_.builder().myBundle(null).myCharSequence(null).build(); + FragmentArguments_.builder().myBundle(null).myCharSequence(null) + .build(); } } diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/FromHtmlActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/FromHtmlActivity.java index ac81e49373..4751f89e16 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/FromHtmlActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/FromHtmlActivity.java @@ -15,13 +15,13 @@ */ package org.androidannotations.test15; -import android.app.Activity; -import android.widget.TextView; - import org.androidannotations.annotations.EActivity; import org.androidannotations.annotations.FromHtml; import org.androidannotations.annotations.ViewById; +import android.app.Activity; +import android.widget.TextView; + @EActivity(R.layout.views_injected) public class FromHtmlActivity extends Activity { diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/HierarchyViewerActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/HierarchyViewerActivity.java index d06321cea8..cd307f8a65 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/HierarchyViewerActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/HierarchyViewerActivity.java @@ -21,5 +21,5 @@ @HierarchyViewerSupport @EActivity(R.layout.clickable_widgets) public class HierarchyViewerActivity extends AbstractActivity { - + } \ No newline at end of file diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ItemClicksHandledActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ItemClicksHandledActivity.java index 1fd0d539e3..41801491c1 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ItemClicksHandledActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ItemClicksHandledActivity.java @@ -15,11 +15,6 @@ */ package org.androidannotations.test15; -import android.app.Activity; -import android.widget.ArrayAdapter; -import android.widget.ListView; -import android.widget.Spinner; - import org.androidannotations.annotations.AfterViews; import org.androidannotations.annotations.EActivity; import org.androidannotations.annotations.ItemClick; @@ -27,6 +22,11 @@ import org.androidannotations.annotations.ItemSelect; import org.androidannotations.annotations.ViewById; +import android.app.Activity; +import android.widget.ArrayAdapter; +import android.widget.ListView; +import android.widget.Spinner; + @EActivity(R.layout.item_clicks_handled) public class ItemClicksHandledActivity extends Activity { @@ -44,7 +44,7 @@ public class ItemClicksHandledActivity extends Activity { @ViewById ListView listViewWithPosition; - + @ViewById ListView listViewWithOneParam; @@ -65,7 +65,8 @@ public class ItemClicksHandledActivity extends Activity { @AfterViews void initView() { - adapter = ArrayAdapter.createFromResource(this, R.array.planets_array, R.layout.simple_spinner_item); + adapter = ArrayAdapter.createFromResource(this, R.array.planets_array, + R.layout.simple_spinner_item); adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); spinner.setAdapter(adapter); @@ -101,23 +102,23 @@ public void spinner() { public void spinnerWithArgument(String selectedItem) { spinnerWithArgumentSelectedItem = selectedItem; } - + @ItemClick void listViewWithPosition(int position) { listViewWithPositionClickedPosition = position; } - + @ItemSelect void listViewWithPositionItemSelected(boolean selected, int position) { listViewWithPositionItemSelected = selected; listViewWithPositionItemSelectedPosition = position; } - + @ItemSelect void listViewWithOneParamItemSelected(boolean selected) { listViewWithOneParamItemSelected = selected; } - + @ItemLongClick void listViewWithPositionItemLongClicked(int position) { diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/LongClicksHandledActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/LongClicksHandledActivity.java index ec94167e71..14114d7486 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/LongClicksHandledActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/LongClicksHandledActivity.java @@ -15,14 +15,14 @@ */ package org.androidannotations.test15; -import android.view.View; - import org.androidannotations.annotations.EActivity; import org.androidannotations.annotations.LongClick; +import android.view.View; + @EActivity(R.layout.clickable_widgets) public class LongClicksHandledActivity extends EventsHandledAbstractActivity { - + @LongClick(R.id.stackOverflowProofButton) public void onLongClick(View v) { avoidStackOverflowEventHandled = true; @@ -32,35 +32,35 @@ public void onLongClick(View v) { public void conventionButton() { conventionButtonEventHandled = true; } - + @LongClick public void snakeCaseButton() { snakeCaseButtonEventHandled = true; - } - + } + @LongClick public void extendedConventionButtonLongClicked() { extendedConventionButtonEventHandled = true; } - + @LongClick(R.id.configurationOverConventionButton) public void overridenConventionButton() { overridenConventionButtonEventHandled = true; } - + public void unboundButton() { unboundButtonEventHandled = true; } - + @LongClick public void buttonWithViewArgument(View viewArgument) { this.viewArgument = viewArgument; } - @LongClick({R.id.button1, R.id.button2}) + @LongClick({ R.id.button1, R.id.button2 }) public void multipleButtonWithViewArgument(View viewArgument) { this.viewArgument = viewArgument; multipleButtonsEventHandled = true; } - + } diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/NoTitleFullscreenActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/NoTitleFullscreenActivity.java index 21c28664ca..4ffcc5f240 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/NoTitleFullscreenActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/NoTitleFullscreenActivity.java @@ -15,12 +15,13 @@ */ package org.androidannotations.test15; -import android.app.Activity; - import org.androidannotations.annotations.EActivity; import org.androidannotations.annotations.Fullscreen; import org.androidannotations.annotations.NoTitle; +import android.app.Activity; + +@SuppressWarnings("deprecation") @EActivity @NoTitle @Fullscreen diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ParcelableSerializableData.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ParcelableSerializableData.java index d5ae931ff1..1e098c5e7d 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ParcelableSerializableData.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ParcelableSerializableData.java @@ -23,7 +23,7 @@ public class ParcelableSerializableData implements Parcelable, Serializable { private static final long serialVersionUID = 920532042616086169L; - + @Override public int describeContents() { return 0; @@ -31,6 +31,6 @@ public int describeContents() { @Override public void writeToParcel(Parcel dest, int flags) { - + } } diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/SSLConnection.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/SSLConnection.java index 5f41e7adeb..0b02036958 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/SSLConnection.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/SSLConnection.java @@ -15,13 +15,12 @@ */ package org.androidannotations.test15; +import org.androidannotations.annotations.EActivity; +import org.androidannotations.annotations.HttpsClient; import org.apache.http.client.HttpClient; import android.app.Activity; -import org.androidannotations.annotations.EActivity; -import org.androidannotations.annotations.HttpsClient; - @EActivity public class SSLConnection extends Activity { diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/SeekBarChangeListenedActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/SeekBarChangeListenedActivity.java index 461f2a0d04..33993e3e1b 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/SeekBarChangeListenedActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/SeekBarChangeListenedActivity.java @@ -15,14 +15,14 @@ */ package org.androidannotations.test15; -import android.app.Activity; -import android.widget.SeekBar; - import org.androidannotations.annotations.EActivity; import org.androidannotations.annotations.SeekBarProgressChange; import org.androidannotations.annotations.SeekBarTouchStart; import org.androidannotations.annotations.SeekBarTouchStop; +import android.app.Activity; +import android.widget.SeekBar; + @EActivity(R.layout.seekbars) public class SeekBarChangeListenedActivity extends Activity { diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/TextWatchedActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/TextWatchedActivity.java index 211675a12f..39c0c74c0d 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/TextWatchedActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/TextWatchedActivity.java @@ -15,70 +15,88 @@ */ package org.androidannotations.test15; -import android.app.Activity; -import android.text.Editable; -import android.widget.TextView; - import org.androidannotations.annotations.AfterTextChange; import org.androidannotations.annotations.BeforeTextChange; import org.androidannotations.annotations.EActivity; import org.androidannotations.annotations.TextChange; +import android.app.Activity; +import android.text.Editable; +import android.widget.TextView; + @EActivity(R.layout.main) public class TextWatchedActivity extends Activity { @AfterTextChange(R.id.helloTextView) - void m1(Editable s) {} + void m1(Editable s) { + } - @AfterTextChange({R.id.helloTextView, R.id.watchedEditText}) - void m2(TextView tv, Editable s) {} + @AfterTextChange({ R.id.helloTextView, R.id.watchedEditText }) + void m2(TextView tv, Editable s) { + } @TextChange(R.id.watchedEditText) - void m3(TextView editText, CharSequence s, int before) {} + void m3(TextView editText, CharSequence s, int before) { + } @TextChange(R.id.watchedEditText) - void m4(TextView editText, CharSequence s, int before) {} + void m4(TextView editText, CharSequence s, int before) { + } @AfterTextChange(R.id.watchedEditText) - void m5(Editable s) {} + void m5(Editable s) { + } @AfterTextChange(R.id.watchedEditText) - void m6(TextView editText, Editable s) {} + void m6(TextView editText, Editable s) { + } @AfterTextChange(R.id.watchedEditText) - void m7(Editable editable, TextView editText) {} + void m7(Editable editable, TextView editText) { + } @TextChange(R.id.helloTextView) - void m8(CharSequence s, int before, int start, int count) {} + void m8(CharSequence s, int before, int start, int count) { + } @TextChange(R.id.helloTextView) - void m9(CharSequence s, int start, int before, int count) {} + void m9(CharSequence s, int start, int before, int count) { + } @TextChange(R.id.helloTextView) - void m10(CharSequence s, int count, int start, int before) {} + void m10(CharSequence s, int count, int start, int before) { + } @BeforeTextChange(R.id.helloTextView) - void m11(CharSequence s) {} + void m11(CharSequence s) { + } @BeforeTextChange(R.id.helloTextView) - void m12(CharSequence s, int count) {} + void m12(CharSequence s, int count) { + } @BeforeTextChange(R.id.helloTextView) - void m14(CharSequence s, int after, int start, int count) {} + void m14(CharSequence s, int after, int start, int count) { + } @BeforeTextChange(R.id.helloTextView) - void m15(TextView tv, CharSequence s, int start, int after, int count) {} + void m15(TextView tv, CharSequence s, int start, int after, int count) { + } @BeforeTextChange(R.id.helloTextView) - void m16(CharSequence s, int count, int start, int after) {} + void m16(CharSequence s, int count, int start, int after) { + } @BeforeTextChange - void helloTextViewBeforeTextChanged() {} + void helloTextViewBeforeTextChanged() { + } @AfterTextChange - void helloTextViewAfterTextChanged() {} + void helloTextViewAfterTextChanged() { + } @TextChange - void helloTextViewTextChanged() {} + void helloTextViewTextChanged() { + } } diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ThreadActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ThreadActivity.java index 52ed8aebbe..f0f09081e8 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ThreadActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ThreadActivity.java @@ -15,8 +15,10 @@ */ package org.androidannotations.test15; -import android.app.Activity; -import android.os.Bundle; +import java.util.List; +import java.util.Map; +import java.util.Set; + import org.androidannotations.annotations.Background; import org.androidannotations.annotations.EActivity; import org.androidannotations.annotations.UiThread; @@ -24,9 +26,8 @@ import org.androidannotations.test15.ebean.SomeBean; import org.androidannotations.test15.instancestate.MySerializableBean; -import java.util.List; -import java.util.Map; -import java.util.Set; +import android.app.Activity; +import android.os.Bundle; @EActivity public class ThreadActivity extends Activity { @@ -45,10 +46,10 @@ void emptyUiMethod() { void emptyBackgroundMethod() { } - + @Background(delay = 1000) void emptyDelayedBackgroundMethod() { - + } @UiThread @@ -67,12 +68,14 @@ void genericUiMethod(List>>> param) { } @Background - void genericBackgroundMethod(List>>> param) { + void genericBackgroundMethod( + List>>> param) { } @Background - void genericBackgroundMethod(Set> param) { + void genericBackgroundMethod( + Set> param) { } @@ -80,16 +83,20 @@ void genericBackgroundMethod(Set> para void emptyUiDelayedMethod() { } - + @UiThread - void uiThreadedUsingArrayParamtersMethod(MySerializableBean [] array) {} + void uiThreadedUsingArrayParamtersMethod(MySerializableBean[] array) { + } @UiThread - void uiThreadedUsingArrayParamtersMethod(MySerializableBean [][] array) {} + void uiThreadedUsingArrayParamtersMethod(MySerializableBean[][] array) { + } @Background - void backgrounddUsingArrayParamtersMethod(MySerializableBean [] array) {} + void backgrounddUsingArrayParamtersMethod(MySerializableBean[] array) { + } @Background - void backgroundUsingArrayParamtersMethod(MySerializableBean [][] array) {} + void backgroundUsingArrayParamtersMethod(MySerializableBean[][] array) { + } } diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/TouchesHandledActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/TouchesHandledActivity.java index dc164839fe..67921f89cb 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/TouchesHandledActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/TouchesHandledActivity.java @@ -15,12 +15,12 @@ */ package org.androidannotations.test15; -import android.view.MotionEvent; -import android.view.View; - import org.androidannotations.annotations.EActivity; import org.androidannotations.annotations.Touch; +import android.view.MotionEvent; +import android.view.View; + @EActivity(R.layout.clickable_widgets) public class TouchesHandledActivity extends EventsHandledAbstractActivity { @@ -28,35 +28,36 @@ public class TouchesHandledActivity extends EventsHandledAbstractActivity { public void conventionButton(MotionEvent evt) { conventionButtonEventHandled = true; } - + @Touch public void snakeCaseButton(MotionEvent evt) { snakeCaseButtonEventHandled = true; - } - + } + @Touch public void extendedConventionButtonTouched(MotionEvent evt) { extendedConventionButtonEventHandled = true; } - + @Touch(R.id.configurationOverConventionButton) public void overridenConventionButton(MotionEvent evt) { overridenConventionButtonEventHandled = true; } - + public void unboundButton(MotionEvent evt) { unboundButtonEventHandled = true; } - + @Touch public void buttonWithViewArgument(MotionEvent evt, View viewArgument) { this.viewArgument = viewArgument; } - @Touch({R.id.button1, R.id.button2}) - public void multipleButtonWithViewArgument(MotionEvent evt, View viewArgument) { + @Touch({ R.id.button1, R.id.button2 }) + public void multipleButtonWithViewArgument(MotionEvent evt, + View viewArgument) { this.viewArgument = viewArgument; multipleButtonsEventHandled = true; } - + } diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/TracedActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/TracedActivity.java index 5c37dd0ef7..9c39b01305 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/TracedActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/TracedActivity.java @@ -15,18 +15,23 @@ */ package org.androidannotations.test15; -import android.app.Activity; -import android.database.sqlite.SQLiteDatabase; -import android.os.Bundle; -import android.util.Log; -import org.androidannotations.annotations.*; -import org.androidannotations.test15.instancestate.MySerializableBean; - import java.io.IOException; import java.util.List; import java.util.Map; import java.util.Set; +import org.androidannotations.annotations.Background; +import org.androidannotations.annotations.EActivity; +import org.androidannotations.annotations.Trace; +import org.androidannotations.annotations.Transactional; +import org.androidannotations.annotations.UiThread; +import org.androidannotations.test15.instancestate.MySerializableBean; + +import android.app.Activity; +import android.database.sqlite.SQLiteDatabase; +import android.os.Bundle; +import android.util.Log; + @EActivity public class TracedActivity extends Activity { @@ -46,13 +51,15 @@ public void onCreate(Bundle savedInstanceState) { } @Trace - Object tracedMethod(List>>> param1, Void param2) throws IOException { + Object tracedMethod(List>>> param1, Void param2) + throws IOException { tracedMethodCalled = true; return null; } @Trace - void voidTracedMethod(List>>> param1, Void param2) throws IOException { + void voidTracedMethod(List>>> param1, Void param2) + throws IOException { voidTracedMethodCalled = true; } @@ -117,8 +124,7 @@ void mixedTransactionalMethod(SQLiteDatabase db) { @Trace void tracedUsingArrayParameters(// - MySerializableBean[] array, - MySerializableBean[][] multiDimArray) { + MySerializableBean[] array, MySerializableBean[][] multiDimArray) { } } diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/TransactionalActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/TransactionalActivity.java index bff0f2efee..dafa8e8787 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/TransactionalActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/TransactionalActivity.java @@ -15,15 +15,16 @@ */ package org.androidannotations.test15; -import android.app.Activity; -import android.database.sqlite.SQLiteDatabase; -import android.os.Bundle; +import java.util.List; + import org.androidannotations.annotations.Background; import org.androidannotations.annotations.EActivity; import org.androidannotations.annotations.Transactional; import org.androidannotations.test15.instancestate.MySerializableBean; -import java.util.List; +import android.app.Activity; +import android.database.sqlite.SQLiteDatabase; +import android.os.Bundle; @EActivity public class TransactionalActivity extends Activity { diff --git a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ViewsInjectedActivity.java b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ViewsInjectedActivity.java index 764a5d5359..f5da957cad 100644 --- a/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ViewsInjectedActivity.java +++ b/AndroidAnnotations/functional-test-1-5/src/main/java/org/androidannotations/test15/ViewsInjectedActivity.java @@ -15,15 +15,15 @@ */ package org.androidannotations.test15; +import org.androidannotations.annotations.AfterViews; +import org.androidannotations.annotations.EActivity; +import org.androidannotations.annotations.ViewById; + import android.app.Activity; import android.view.View; import android.widget.Button; import android.widget.TextView; -import org.androidannotations.annotations.AfterViews; -import org.androidannotations.annotations.EActivity; -import org.androidannotations.annotations.ViewById; - @EActivity(R.layout.views_injected) public class ViewsInjectedActivity extends Activity { From 3fdc190313e1859fc9d4bd17bba50cf4380705c9 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 13 Jun 2013 14:55:58 +0200 Subject: [PATCH 76/86] Make validation inheritance easier --- .../handler/AbstractListenerHandler.java | 6 +----- .../handler/AbstractRunnableHandler.java | 6 +----- .../handler/AbstractSeekBarTouchHandler.java | 6 +----- .../handler/AfterInjectHandler.java | 6 +----- .../handler/AfterTextChangeHandler.java | 6 +----- .../androidannotations/handler/AfterViewsHandler.java | 6 +----- .../org/androidannotations/handler/AppHandler.java | 6 +----- .../handler/BaseAnnotationHandler.java | 11 +++++++++++ .../org/androidannotations/handler/BeanHandler.java | 6 +----- .../handler/BeforeTextChangeHandler.java | 6 +----- .../handler/CheckedChangeHandler.java | 10 ++-------- .../org/androidannotations/handler/ClickHandler.java | 10 ++-------- .../handler/CustomTitleHandler.java | 6 +----- .../androidannotations/handler/EActivityHandler.java | 6 +----- .../handler/EApplicationHandler.java | 6 +----- .../org/androidannotations/handler/EBeanHandler.java | 6 +----- .../androidannotations/handler/EFragmentHandler.java | 6 +----- .../androidannotations/handler/EProviderHandler.java | 6 +----- .../androidannotations/handler/EReceiverHandler.java | 6 +----- .../androidannotations/handler/EServiceHandler.java | 6 +----- .../androidannotations/handler/EViewGroupHandler.java | 6 +----- .../org/androidannotations/handler/EViewHandler.java | 6 +----- .../org/androidannotations/handler/ExtraHandler.java | 6 +----- .../handler/FocusChangeHandler.java | 11 +++-------- .../handler/FragmentArgHandler.java | 6 +----- .../handler/FragmentByIdHandler.java | 6 +----- .../handler/FragmentByTagHandler.java | 6 +----- .../androidannotations/handler/FromHtmlHandler.java | 6 +----- .../androidannotations/handler/FullscreenHandler.java | 6 +----- .../handler/HierarchyViewerSupportHandler.java | 6 +----- .../handler/HttpsClientHandler.java | 6 +----- .../handler/InstanceStateHandler.java | 6 +----- .../androidannotations/handler/ItemClickHandler.java | 10 ++-------- .../handler/ItemLongClickHandler.java | 10 ++-------- .../androidannotations/handler/ItemSelectHandler.java | 10 ++-------- .../androidannotations/handler/LongClickHandler.java | 10 ++-------- .../androidannotations/handler/NoTitleHandler.java | 6 +----- .../handler/NonConfigurationInstanceHandler.java | 6 +----- .../handler/OnActivityResultHandler.java | 6 +----- .../handler/OptionsItemHandler.java | 6 +----- .../handler/OptionsMenuHandler.java | 6 +----- .../handler/OptionsMenuItemHandler.java | 6 +----- .../androidannotations/handler/OrmLiteDaoHandler.java | 6 +----- .../org/androidannotations/handler/PrefHandler.java | 6 +----- .../androidannotations/handler/ProduceHandler.java | 9 +++------ .../org/androidannotations/handler/ResHandler.java | 6 +----- .../androidannotations/handler/RoboGuiceHandler.java | 6 +----- .../handler/RootContextHanlder.java | 6 +----- .../handler/SeekBarProgressChangeHandler.java | 6 +----- .../androidannotations/handler/SharedPrefHandler.java | 6 +----- .../androidannotations/handler/SubscribeHandler.java | 9 +++------ .../handler/SystemServiceHandler.java | 6 +----- .../androidannotations/handler/TextChangeHandler.java | 6 +----- .../org/androidannotations/handler/TouchHandler.java | 10 ++-------- .../org/androidannotations/handler/TraceHandler.java | 6 +----- .../handler/TransactionalHandler.java | 6 +----- .../androidannotations/handler/ViewByIdHandler.java | 6 +----- .../handler/WindowFeatureHandler.java | 6 +----- .../handler/rest/DeleteHandler.java | 10 ++-------- .../androidannotations/handler/rest/GetHandler.java | 10 ++-------- .../androidannotations/handler/rest/HeadHandler.java | 10 ++-------- .../handler/rest/OptionsHandler.java | 10 ++-------- .../androidannotations/handler/rest/PostHandler.java | 10 ++-------- .../androidannotations/handler/rest/PutHandler.java | 10 ++-------- .../androidannotations/handler/rest/RestHandler.java | 6 +----- .../handler/rest/RestMethodHandler.java | 6 +----- .../handler/rest/RestServiceHandler.java | 6 +----- 67 files changed, 96 insertions(+), 374 deletions(-) diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java index bff3ffa187..7d4ecda15d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java @@ -70,9 +70,7 @@ public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidS } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); validatorHelper.resIdsExist(element, IRClass.Res.ID, IdValidatorHelper.FallbackStrategy.USE_ELEMENT_NAME, valid); @@ -82,8 +80,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.doesntThrowException(element, valid); validatorHelper.uniqueId(element, validatedElements, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractRunnableHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractRunnableHandler.java index c6fb5cea7f..8f7e653fb4 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractRunnableHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractRunnableHandler.java @@ -30,9 +30,7 @@ public AbstractRunnableHandler(Class targetClass, ProcessingEnvironment proce } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); ExecutableElement executableElement = (ExecutableElement) element; @@ -46,7 +44,5 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.isNotFinal(element, valid); validatorHelper.isNotSynchronized(element, valid); - - return valid.isValid(); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractSeekBarTouchHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractSeekBarTouchHandler.java index 9a1522ae15..af3a81e0e8 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractSeekBarTouchHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractSeekBarTouchHandler.java @@ -53,9 +53,7 @@ public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidS } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); validatorHelper.resIdsExist(element, IRClass.Res.ID, IdValidatorHelper.FallbackStrategy.USE_ELEMENT_NAME, valid); @@ -67,8 +65,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.returnTypeIsVoid((ExecutableElement) element, valid); validatorHelper.hasSeekBarTouchTrackingMethodParameters((ExecutableElement) element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterInjectHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterInjectHandler.java index e58768637d..74584bd09d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterInjectHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterInjectHandler.java @@ -31,9 +31,7 @@ public AfterInjectHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); ExecutableElement executableElement = (ExecutableElement) element; @@ -45,8 +43,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.doesntThrowException(executableElement, valid); validatorHelper.param.zeroParameter(executableElement, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterTextChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterTextChangeHandler.java index d0411f1695..181959988c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterTextChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterTextChangeHandler.java @@ -56,9 +56,7 @@ public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidS } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); validatorHelper.resIdsExist(element, IRClass.Res.ID, IdValidatorHelper.FallbackStrategy.USE_ELEMENT_NAME, valid); @@ -70,8 +68,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.returnTypeIsVoid((ExecutableElement) element, valid); validatorHelper.hasAfterTextChangedMethodParameters((ExecutableElement) element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterViewsHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterViewsHandler.java index 251c55d0b2..a866b6c6f8 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterViewsHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterViewsHandler.java @@ -31,9 +31,7 @@ public AfterViewsHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); ExecutableElement executableElement = (ExecutableElement) element; @@ -45,8 +43,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.doesntThrowException(executableElement, valid); validatorHelper.param.zeroParameter(executableElement, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java index 5ebfbdce83..193e336c57 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java @@ -37,16 +37,12 @@ public AppHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); validatorHelper.typeHasAnnotation(EApplication.class, element, valid); validatorHelper.isNotPrivate(element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BaseAnnotationHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BaseAnnotationHandler.java index 3f4bb69e20..8e9f5b841e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BaseAnnotationHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BaseAnnotationHandler.java @@ -16,6 +16,7 @@ package org.androidannotations.handler; import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.IdAnnotationHelper; @@ -23,6 +24,7 @@ import org.androidannotations.holder.GeneratedClassHolder; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.IsValid; import org.androidannotations.rclass.IRClass; public abstract class BaseAnnotationHandler implements AnnotationHandler { @@ -66,4 +68,13 @@ public void setValidatedModel(AnnotationElements validatedModel) { public String getTarget() { return target; } + + @Override + public boolean validate(Element element, AnnotationElements validatedElements) { + IsValid valid = new IsValid(); + validate(element, validatedElements, valid); + return valid.isValid(); + } + + protected abstract void validate(Element element, AnnotationElements validatedElements, IsValid valid); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java index 390c26cf14..a7a7a840bb 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java @@ -47,16 +47,12 @@ public BeanHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); validatorHelper.isNotPrivate(element, valid); validatorHelper.typeOrTargetValueHasAnnotation(EBean.class, element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeforeTextChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeforeTextChangeHandler.java index 9dcf4b026e..69ba6b405f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeforeTextChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeforeTextChangeHandler.java @@ -57,9 +57,7 @@ public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidS } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); validatorHelper.resIdsExist(element, IRClass.Res.ID, IdValidatorHelper.FallbackStrategy.USE_ELEMENT_NAME, valid); @@ -71,8 +69,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.returnTypeIsVoid((ExecutableElement) element, valid); validatorHelper.hasBeforeTextChangedMethodParameters((ExecutableElement) element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CheckedChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CheckedChangeHandler.java index e61ea81c13..7986717f9e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CheckedChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CheckedChangeHandler.java @@ -43,19 +43,13 @@ public CheckedChangeHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - - if (!super.validate(element, validatedElements)) { - valid.invalidate(); - } + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { + super.validate(element, validatedElements, valid); ExecutableElement executableElement = (ExecutableElement) element; validatorHelper.returnTypeIsVoid(executableElement, valid); validatorHelper.param.hasZeroOrOneCompoundButtonOrTwoCompoundButtonBooleanParameters(executableElement, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ClickHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ClickHandler.java index 4e10d400a8..c723f481af 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ClickHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ClickHandler.java @@ -42,20 +42,14 @@ public ClickHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - - if (!super.validate(element, validatedElements)) { - valid.invalidate(); - } + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { + super.validate(element, validatedElements, valid); ExecutableElement executableElement = (ExecutableElement) element; validatorHelper.returnTypeIsVoid(executableElement, valid); validatorHelper.param.zeroOrOneViewParameter(executableElement, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java index c9bc8f4a4e..4e953864c4 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java @@ -39,14 +39,10 @@ public CustomTitleHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.hasEActivity(element, validatedElements, valid); validatorHelper.resIdsExist(element, IRClass.Res.LAYOUT, IdValidatorHelper.FallbackStrategy.NEED_RES_ID, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EActivityHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EActivityHandler.java index b31b0fc8a2..2997463f38 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EActivityHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EActivityHandler.java @@ -49,9 +49,7 @@ public EActivityHolder createGeneratedClassHolder(ProcessHolder processHolder, T } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.extendsActivity(element, valid); validatorHelper.resIdsExist(element, IRClass.Res.LAYOUT, IdValidatorHelper.FallbackStrategy.ALLOW_NO_RES_ID, valid); @@ -59,8 +57,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.isNotFinal(element, valid); validatorHelper.componentRegistered(element, androidManifest, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EApplicationHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EApplicationHandler.java index 94b3d32b6b..18f44c695d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EApplicationHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EApplicationHandler.java @@ -37,16 +37,12 @@ public EApplicationHolder createGeneratedClassHolder(ProcessHolder processHolder } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.extendsApplication(element, valid); validatorHelper.isNotFinal(element, valid); validatorHelper.applicationRegistered(element, androidManifest, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EBeanHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EBeanHandler.java index e4d77569a5..d495accaed 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EBeanHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EBeanHandler.java @@ -37,16 +37,12 @@ public EBeanHolder createGeneratedClassHolder(ProcessHolder processHolder, TypeE } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.isNotFinal(element, valid); validatorHelper.isNotPrivate(element, valid); validatorHelper.hasEmptyOrContextConstructor(element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EFragmentHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EFragmentHandler.java index d671fd2987..0dfe6ce04b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EFragmentHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EFragmentHandler.java @@ -48,9 +48,7 @@ public EFragmentHolder createGeneratedClassHolder(ProcessHolder processHolder, T } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.isNotFinal(element, valid); validatorHelper.resIdsExist(element, IRClass.Res.LAYOUT, IdValidatorHelper.FallbackStrategy.ALLOW_NO_RES_ID, valid); @@ -60,8 +58,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.hasEmptyConstructor(element, valid); validatorHelper.extendsFragment(element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EProviderHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EProviderHandler.java index 9e61c9e5f4..1f35342f18 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EProviderHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EProviderHandler.java @@ -37,16 +37,12 @@ public EProviderHolder createGeneratedClassHolder(ProcessHolder processHolder, T } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.extendsProvider(element, valid); validatorHelper.isNotFinal(element, valid); validatorHelper.componentRegistered(element, androidManifest, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EReceiverHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EReceiverHandler.java index 957aa7cb7f..2de796c221 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EReceiverHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EReceiverHandler.java @@ -37,17 +37,13 @@ public EReceiverHolder createGeneratedClassHolder(ProcessHolder processHolder, T } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.extendsReceiver(element, valid); validatorHelper.isNotFinal(element, valid); final boolean NO_WARNING = false; validatorHelper.componentRegistered(element, androidManifest, NO_WARNING, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EServiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EServiceHandler.java index 3677ff29c7..c9d806a853 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EServiceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EServiceHandler.java @@ -37,16 +37,12 @@ public EServiceHolder createGeneratedClassHolder(ProcessHolder processHolder, Ty } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.extendsService(element, valid); validatorHelper.isNotFinal(element, valid); validatorHelper.componentRegistered(element, androidManifest, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewGroupHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewGroupHandler.java index b2a3c6ced8..43ad0568d7 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewGroupHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewGroupHandler.java @@ -53,16 +53,12 @@ public EViewGroupHolder createGeneratedClassHolder(ProcessHolder processHolder, } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.extendsViewGroup(element, valid); validatorHelper.resIdsExist(element, IRClass.Res.LAYOUT, IdValidatorHelper.FallbackStrategy.ALLOW_NO_RES_ID, valid); validatorHelper.isNotFinal(element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewHandler.java index 87ae3d6b0b..77dc346e23 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewHandler.java @@ -37,14 +37,10 @@ public EViewHolder createGeneratedClassHolder(ProcessHolder processHolder, TypeE } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.extendsView(element, valid); validatorHelper.isNotFinal(element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java index adadca133f..2cac24cccd 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java @@ -65,9 +65,7 @@ public ExtraHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { /* * TODO since we override setIntent(), we should check that the * setIntent() method can be overridden @@ -76,8 +74,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.enclosingElementHasEActivity(element, validatedElements, valid); validatorHelper.isNotPrivate(element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FocusChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FocusChangeHandler.java index 282b301f83..83ab17b234 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FocusChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FocusChangeHandler.java @@ -42,19 +42,14 @@ public FocusChangeHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - - if (!super.validate(element, validatedElements)) { - valid.invalidate(); - } + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { + super.validate(element, validatedElements, valid); ExecutableElement executableElement = (ExecutableElement) element; + validatorHelper.returnTypeIsVoid(executableElement, valid); validatorHelper.param.hasZeroOrOneViewOrTwoViewBooleanParameters(executableElement, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentArgHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentArgHandler.java index 5b92496211..9c14ce8203 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentArgHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentArgHandler.java @@ -55,14 +55,10 @@ public FragmentArgHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEFragment(element, validatedElements, valid); validatorHelper.isNotPrivate(element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java index d764e12fd7..7dec5c628f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java @@ -54,9 +54,7 @@ public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidS } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); validatorHelper.extendsFragment(element, valid); @@ -64,8 +62,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.resIdsExist(element, IRClass.Res.ID, IdValidatorHelper.FallbackStrategy.USE_ELEMENT_NAME, valid); validatorHelper.isNotPrivate(element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java index b97d5f78c2..91e1f30cd7 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java @@ -52,16 +52,12 @@ public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidS } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); validatorHelper.extendsFragment(element, valid); validatorHelper.isNotPrivate(element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java index 7d45af5e9e..93872630f8 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java @@ -50,9 +50,7 @@ public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidS } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); validatorHelper.hasViewByIdAnnotation(element, validatedElements, valid); @@ -60,8 +58,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.extendsTextView(element, valid); validatorHelper.resIdsExist(element, IRClass.Res.STRING, IdValidatorHelper.FallbackStrategy.USE_ELEMENT_NAME, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java index a33343b092..b313c2442d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java @@ -32,12 +32,8 @@ public FullscreenHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.hasEActivity(element, validatedElements, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HierarchyViewerSupportHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HierarchyViewerSupportHandler.java index 743ec4d6d9..bafbe75b9e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HierarchyViewerSupportHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HierarchyViewerSupportHandler.java @@ -35,16 +35,12 @@ public HierarchyViewerSupportHandler(ProcessingEnvironment processingEnvironment } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.hasEActivity(element, validatedElements, valid); validatorHelper.isDebuggable(element, androidManifest, valid); validatorHelper.hasInternetPermission(element, androidManifest, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java index 4bcf8c0af3..44ed4850f0 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java @@ -53,17 +53,13 @@ public HttpsClientHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); validatorHelper.annotationParameterIsOptionalValidResId(element, IRClass.Res.RAW, "keyStore", valid); validatorHelper.annotationParameterIsOptionalValidResId(element, IRClass.Res.RAW, "trustStore", valid); validatorHelper.isNotPrivate(element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/InstanceStateHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/InstanceStateHandler.java index c9d6ba27b5..2aca2214d8 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/InstanceStateHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/InstanceStateHandler.java @@ -44,16 +44,12 @@ public InstanceStateHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEActivityOrEFragment(element, validatedElements, valid); validatorHelper.isNotPrivate(element, valid); validatorHelper.canBeSavedAsInstanceState(element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemClickHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemClickHandler.java index 1d16a9b9f9..1f19f01cec 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemClickHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemClickHandler.java @@ -47,20 +47,14 @@ public ItemClickHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - - if (!super.validate(element, validatedElements)) { - valid.invalidate(); - } + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { + super.validate(element, validatedElements, valid); ExecutableElement executableElement = (ExecutableElement) element; validatorHelper.returnTypeIsVoid(executableElement, valid); validatorHelper.param.zeroOrOneParameter(executableElement, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemLongClickHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemLongClickHandler.java index 89c72a48d0..1b43d870a0 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemLongClickHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemLongClickHandler.java @@ -48,20 +48,14 @@ public ItemLongClickHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - - if (!super.validate(element, validatedElements)) { - valid.invalidate(); - } + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { + super.validate(element, validatedElements, valid); ExecutableElement executableElement = (ExecutableElement) element; validatorHelper.returnTypeIsVoidOrBoolean(executableElement, valid); validatorHelper.param.zeroOrOneParameter(executableElement, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemSelectHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemSelectHandler.java index bf0a472a56..7091d6e83c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemSelectHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ItemSelectHandler.java @@ -51,20 +51,14 @@ public ItemSelectHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - - if (!super.validate(element, validatedElements)) { - valid.invalidate(); - } + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { + super.validate(element, validatedElements, valid); ExecutableElement executableElement = (ExecutableElement) element; validatorHelper.returnTypeIsVoid(executableElement, valid); validatorHelper.param.hasOneOrTwoParametersAndFirstIsBoolean(executableElement, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/LongClickHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/LongClickHandler.java index 172827d497..4e5c9f07cd 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/LongClickHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/LongClickHandler.java @@ -44,20 +44,14 @@ public LongClickHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - - if (!super.validate(element, validatedElements)) { - valid.invalidate(); - } + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { + super.validate(element, validatedElements, valid); ExecutableElement executableElement = (ExecutableElement) element; validatorHelper.returnTypeIsVoidOrBoolean(executableElement, valid); validatorHelper.param.zeroOrOneViewParameter(executableElement, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java index 3937071c6e..de63301536 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java @@ -33,12 +33,8 @@ public NoTitleHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.hasEActivity(element, validatedElements, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NonConfigurationInstanceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NonConfigurationInstanceHandler.java index faed6fba02..9f82dd28c1 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NonConfigurationInstanceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NonConfigurationInstanceHandler.java @@ -51,14 +51,10 @@ public NonConfigurationInstanceHandler(ProcessingEnvironment processingEnvironme } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEActivity(element, validatedElements, valid); validatorHelper.isNotPrivate(element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OnActivityResultHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OnActivityResultHandler.java index 75bb137b10..3069dfe899 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OnActivityResultHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OnActivityResultHandler.java @@ -42,9 +42,7 @@ public OnActivityResultHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEActivityOrEFragment(element, validatedElements, valid); validatorHelper.isNotPrivate(element, valid); @@ -58,8 +56,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.returnTypeIsVoid(executableElement, valid); validatorHelper.hasOnResultMethodParameters(executableElement, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsItemHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsItemHandler.java index 709381fd10..31d11990fe 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsItemHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsItemHandler.java @@ -57,9 +57,7 @@ public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidS } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEActivityOrEFragment(element, validatedElements, valid); validatorHelper.resIdsExist(element, IRClass.Res.ID, IdValidatorHelper.FallbackStrategy.USE_ELEMENT_NAME, valid); @@ -75,8 +73,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.returnTypeIsVoidOrBoolean(executableElement, valid); validatorHelper.param.zeroOrOneMenuItemParameter(executableElement, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuHandler.java index da00333f47..efd610b158 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuHandler.java @@ -49,14 +49,10 @@ public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidS } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.hasEActivityOrEFragment(element, validatedElements, valid); validatorHelper.resIdsExist(element, IRClass.Res.MENU, IdValidatorHelper.FallbackStrategy.NEED_RES_ID, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuItemHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuItemHandler.java index 083e786f81..76dd025930 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuItemHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuItemHandler.java @@ -49,9 +49,7 @@ public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidS } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEActivityOrEFragment(element, validatedElements, valid); validatorHelper.isDeclaredType(element, valid); @@ -61,8 +59,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.resIdsExist(element, IRClass.Res.ID, IdValidatorHelper.FallbackStrategy.USE_ELEMENT_NAME, valid); validatorHelper.isNotPrivate(element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java index 0340ba8a33..d5f77b4ea4 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java @@ -44,9 +44,7 @@ public OrmLiteDaoHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.hasOrmLiteJars(element, valid); validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); @@ -56,8 +54,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.extendsOrmLiteDaoWithValidModelParameter(element, valid); validatorHelper.hasASqlLiteOpenHelperParameterizedType(element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java index 94fafc5729..d4458a970b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java @@ -43,16 +43,12 @@ public PrefHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); validatorHelper.isNotPrivate(element, valid); validatorHelper.isSharedPreference(element, validatedElements, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ProduceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ProduceHandler.java index 20edbfe093..2443918492 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ProduceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ProduceHandler.java @@ -41,13 +41,12 @@ public ProduceHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { if (!annotationHelper.enclosingElementHasEnhancedComponentAnnotation(element)) { - return false; + valid.invalidate(); + return; } - IsValid valid = new IsValid(); - ExecutableElement executableElement = (ExecutableElement) element; /* @@ -64,8 +63,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.isNotFinal(element, valid); validatorHelper.param.zeroParameter(executableElement, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java index 0a9c335a11..1496cd0ad2 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java @@ -55,9 +55,7 @@ public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidS } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); TypeMirror fieldTypeMirror = element.asType(); @@ -67,8 +65,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.resIdsExist(element, androidRes.getRInnerClass(), IdValidatorHelper.FallbackStrategy.USE_ELEMENT_NAME, valid); validatorHelper.isNotPrivate(element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java index 3275b4ad71..8b1e2f3f37 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java @@ -54,14 +54,10 @@ public RoboGuiceHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.hasEActivity(element, validatedElements, valid); validatorHelper.hasRoboGuiceJars(element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java index f83acdc7b0..df060a18d7 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java @@ -39,16 +39,12 @@ public RootContextHanlder(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEBeanAnnotation(element, validatedElements, valid); validatorHelper.extendsContext(element, valid); validatorHelper.isNotPrivate(element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarProgressChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarProgressChangeHandler.java index 44b9b47ba5..c3f6168a27 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarProgressChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarProgressChangeHandler.java @@ -57,9 +57,7 @@ public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidS } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); validatorHelper.resIdsExist(element, IRClass.Res.ID, IdValidatorHelper.FallbackStrategy.USE_ELEMENT_NAME, valid); @@ -71,8 +69,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.returnTypeIsVoid((ExecutableElement) element, valid); validatorHelper.hasSeekBarProgressChangeMethodParameters((ExecutableElement) element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SharedPrefHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SharedPrefHandler.java index 7df810bd30..6a6b80d2b9 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SharedPrefHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SharedPrefHandler.java @@ -89,9 +89,7 @@ public SharedPrefHolder createGeneratedClassHolder(ProcessHolder processHolder, } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { TypeElement typeElement = (TypeElement) element; validatorHelper.isInterface(typeElement, valid); @@ -106,8 +104,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { } } } - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SubscribeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SubscribeHandler.java index bb4cb13618..d5305339a0 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SubscribeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SubscribeHandler.java @@ -41,13 +41,12 @@ public SubscribeHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { if (!annotationHelper.enclosingElementHasEnhancedComponentAnnotation(element)) { - return false; + valid.invalidate(); + return; } - IsValid valid = new IsValid(); - ExecutableElement executableElement = (ExecutableElement) element; /* @@ -64,8 +63,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.isNotFinal(element, valid); validatorHelper.param.hasExactlyOneParameter(executableElement, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java index 6590802a4d..088c758130 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java @@ -37,16 +37,12 @@ public SystemServiceHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); validatorHelper.androidService(androidSystemServices, element, valid); validatorHelper.isNotPrivate(element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TextChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TextChangeHandler.java index 1c0d93a33b..dfc94780c0 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TextChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TextChangeHandler.java @@ -57,9 +57,7 @@ public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidS } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); validatorHelper.resIdsExist(element, IRClass.Res.ID, IdValidatorHelper.FallbackStrategy.USE_ELEMENT_NAME, valid); @@ -71,8 +69,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.returnTypeIsVoid((ExecutableElement) element, valid); validatorHelper.hasTextChangedMethodParameters((ExecutableElement) element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TouchHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TouchHandler.java index 5b7b9ca010..0459636906 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TouchHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TouchHandler.java @@ -44,20 +44,14 @@ public TouchHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - - if (!super.validate(element, validatedElements)) { - valid.invalidate(); - } + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { + super.validate(element, validatedElements, valid); ExecutableElement executableElement = (ExecutableElement) element; validatorHelper.returnTypeIsVoidOrBoolean(executableElement, valid); validatorHelper.param.hasOneMotionEventOrTwoMotionEventViewParameters(executableElement, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TraceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TraceHandler.java index 76632286b2..e49c8dc15c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TraceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TraceHandler.java @@ -53,16 +53,12 @@ public TraceHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); validatorHelper.isNotPrivate(element, valid); validatorHelper.hasValidLogLevel(element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TransactionalHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TransactionalHandler.java index 0ecab9b9c0..d8ef149509 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TransactionalHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TransactionalHandler.java @@ -44,9 +44,7 @@ public TransactionalHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); validatorHelper.isNotPrivate(element, valid); @@ -58,8 +56,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.isNotFinal(element, valid); validatorHelper.param.hasOneOrTwoParametersAndFirstIsDb(executableElement, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java index 1fc3efbb5d..52b702c120 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java @@ -50,9 +50,7 @@ public void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidS } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEnhancedViewSupportAnnotation(element, validatedElements, valid); validatorHelper.isDeclaredType(element, valid); @@ -62,8 +60,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.resIdsExist(element, IRClass.Res.ID, IdValidatorHelper.FallbackStrategy.USE_ELEMENT_NAME, valid); validatorHelper.isNotPrivate(element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/WindowFeatureHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/WindowFeatureHandler.java index 42979d48ba..03e636fa33 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/WindowFeatureHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/WindowFeatureHandler.java @@ -32,12 +32,8 @@ public WindowFeatureHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.hasEActivity(element, validatedElements, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/DeleteHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/DeleteHandler.java index 84ac206b70..edc1ed5e0e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/DeleteHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/DeleteHandler.java @@ -31,18 +31,12 @@ public DeleteHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - - if (!super.validate(element, validatedElements)) { - valid.invalidate(); - } + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { + super.validate(element, validatedElements, valid); validatorHelper.returnTypeIsVoid((ExecutableElement) element, valid); restAnnotationHelper.urlVariableNamesExistInParametersAndHasNoOneMoreParameter((ExecutableElement) element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/GetHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/GetHandler.java index ad7d0d1431..f861a3a565 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/GetHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/GetHandler.java @@ -34,18 +34,12 @@ public GetHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - - if (!super.validate(element, validatedElements)) { - valid.invalidate(); - } + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { + super.validate(element, validatedElements, valid); validatorHelper.doesNotReturnPrimitive((ExecutableElement) element, valid); restAnnotationHelper.urlVariableNamesExistInParametersAndHasNoOneMoreParameter((ExecutableElement) element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/HeadHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/HeadHandler.java index 3a7a7ef419..89189bdde1 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/HeadHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/HeadHandler.java @@ -34,18 +34,12 @@ public HeadHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - - if (!super.validate(element, validatedElements)) { - valid.invalidate(); - } + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { + super.validate(element, validatedElements, valid); validatorHelper.hasHttpHeadersReturnType((ExecutableElement) element, valid); restAnnotationHelper.urlVariableNamesExistInParametersAndHasNoOneMoreParameter((ExecutableElement) element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/OptionsHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/OptionsHandler.java index e2928efa8d..e6c9c2d899 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/OptionsHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/OptionsHandler.java @@ -32,18 +32,12 @@ public OptionsHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - - if (!super.validate(element, validatedElements)) { - valid.invalidate(); - } + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { + super.validate(element, validatedElements, valid); validatorHelper.hasSetOfHttpMethodReturnType((ExecutableElement) element, valid); restAnnotationHelper.urlVariableNamesExistInParametersAndHasNoOneMoreParameter((ExecutableElement) element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PostHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PostHandler.java index 0d2360ef5f..aaf735e4ca 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PostHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PostHandler.java @@ -34,18 +34,12 @@ public PostHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - - if (!super.validate(element, validatedElements)) { - valid.invalidate(); - } + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { + super.validate(element, validatedElements, valid); validatorHelper.doesNotReturnPrimitive((ExecutableElement) element, valid); restAnnotationHelper.urlVariableNamesExistInParametersAndHasOnlyOneMoreParameter((ExecutableElement) element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PutHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PutHandler.java index 8015cd2f4a..29c4e37671 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PutHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PutHandler.java @@ -36,18 +36,12 @@ public PutHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - - if (!super.validate(element, validatedElements)) { - valid.invalidate(); - } + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { + super.validate(element, validatedElements, valid); validatorHelper.returnTypeIsVoid((ExecutableElement) element, valid); restAnnotationHelper.urlVariableNamesExistInParametersAndHasOnlyOneMoreParameter((ExecutableElement) element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestHandler.java index c397b19418..10e077e735 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestHandler.java @@ -52,9 +52,7 @@ public RestHolder createGeneratedClassHolder(ProcessHolder processHolder, TypeEl } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { TypeElement typeElement = (TypeElement) element; validatorHelper.notAlreadyValidated(element, validatedElements, valid); @@ -74,8 +72,6 @@ public boolean validate(Element element, AnnotationElements validatedElements) { validatorHelper.validateInterceptors(element, valid); validatorHelper.hasInternetPermission(typeElement, androidManifest, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java index 88677033a7..14b9cc85be 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java @@ -44,16 +44,12 @@ public RestMethodHandler(Class targetClass, ProcessingEnvironment processingE } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.notAlreadyValidated(element, validatedElements, valid); validatorHelper.enclosingElementHasRestAnnotation(element, validatedElements, valid); validatorHelper.throwsOnlyRestClientException((ExecutableElement) element, valid); - - return valid.isValid(); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestServiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestServiceHandler.java index 43696febab..3e9759da83 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestServiceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestServiceHandler.java @@ -37,16 +37,12 @@ public RestServiceHandler(ProcessingEnvironment processingEnvironment) { } @Override - public boolean validate(Element element, AnnotationElements validatedElements) { - IsValid valid = new IsValid(); - + public void validate(Element element, AnnotationElements validatedElements, IsValid valid) { validatorHelper.enclosingElementHasEnhancedComponentAnnotation(element, validatedElements, valid); validatorHelper.isNotPrivate(element, valid); validatorHelper.typeHasAnnotation(Rest.class, element, valid); - - return valid.isValid(); } @Override From 993167908d433c55a17a65b27e1b7d23a40545f6 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Thu, 13 Jun 2013 16:15:15 +0200 Subject: [PATCH 77/86] Make AnnotationHandler aware of the ProcessHolder --- .../handler/AbstractListenerHandler.java | 19 +------- .../handler/AbstractSeekBarTouchHandler.java | 2 +- .../handler/AfterTextChangeHandler.java | 2 +- .../handler/AnnotationHandler.java | 3 ++ .../handler/AnnotationHandlers.java | 7 +++ .../handler/AppHandler.java | 2 +- .../handler/BackgroundHandler.java | 8 ++-- .../handler/BaseAnnotationHandler.java | 33 ++++++++++++++ .../handler/BeanHandler.java | 2 +- .../handler/BeforeTextChangeHandler.java | 2 +- .../handler/CustomTitleHandler.java | 4 +- .../handler/EActivityHandler.java | 2 +- .../handler/EFragmentHandler.java | 2 +- .../handler/EViewGroupHandler.java | 2 +- .../handler/ExtraHandler.java | 6 +-- .../handler/FragmentArgHandler.java | 2 +- .../handler/FragmentByIdHandler.java | 4 +- .../handler/FragmentByTagHandler.java | 2 +- .../handler/FromHtmlHandler.java | 6 +-- .../handler/FullscreenHandler.java | 2 +- .../HierarchyViewerSupportHandler.java | 4 +- .../handler/HttpsClientHandler.java | 8 ++-- .../handler/NoTitleHandler.java | 2 +- .../NonConfigurationInstanceHandler.java | 6 +-- .../handler/OptionsItemHandler.java | 2 +- .../handler/OptionsMenuHandler.java | 2 +- .../handler/OptionsMenuItemHandler.java | 2 +- .../handler/OrmLiteDaoHandler.java | 6 +-- .../handler/PrefHandler.java | 2 +- .../handler/ProduceHandler.java | 2 +- .../handler/ResHandler.java | 8 ++-- .../handler/RoboGuiceHandler.java | 38 ++++++++-------- .../handler/RootContextHanlder.java | 2 +- .../handler/SeekBarProgressChangeHandler.java | 2 +- .../handler/SharedPrefHandler.java | 44 +++++++++---------- .../handler/SubscribeHandler.java | 2 +- .../handler/SystemServiceHandler.java | 2 +- .../handler/TextChangeHandler.java | 2 +- .../handler/TraceHandler.java | 16 +++---- .../handler/TransactionalHandler.java | 6 +-- .../handler/ViewByIdHandler.java | 4 +- .../handler/rest/GetHandler.java | 6 +-- .../handler/rest/PostHandler.java | 6 +-- .../handler/rest/PutHandler.java | 4 +- .../handler/rest/RestHandler.java | 8 ++-- .../handler/rest/RestMethodHandler.java | 18 ++++---- .../handler/rest/RestServiceHandler.java | 2 +- .../helper/APTCodeModelHelper.java | 4 +- .../helper/AnnotationHelper.java | 3 +- .../helper/IdAnnotationHelper.java | 7 +-- .../helper/RestAnnotationHelper.java | 9 ++-- .../holder/BaseGeneratedClassHolder.java | 6 --- .../holder/GeneratedClassHolder.java | 14 +++--- .../holder/InstanceStateHolder.java | 6 --- .../holder/RoboGuiceHolder.java | 4 -- .../process/ModelProcessor.java | 2 + .../rclass/CoumpoundInnerClass.java | 7 ++- .../rclass/IRInnerClass.java | 7 ++- .../rclass/RInnerClass.java | 8 ++-- 59 files changed, 200 insertions(+), 195 deletions(-) diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java index 7d4ecda15d..5232e3823a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractListenerHandler.java @@ -52,7 +52,6 @@ public abstract class AbstractListenerHandler extends BaseAnnotationHandler { private IdAnnotationHelper helper; - private EComponentWithViewSupportHolder holder; private String methodName; public AbstractListenerHandler(Class targetClass, ProcessingEnvironment processingEnvironment) { @@ -84,17 +83,15 @@ public void validate(Element element, AnnotationElements validatedElements, IsVa @Override public void process(Element element, EComponentWithViewSupportHolder holder) { - this.holder = holder; - this.methodName = element.getSimpleName().toString(); ExecutableElement executableElement = (ExecutableElement) element; List parameters = executableElement.getParameters(); TypeMirror returnType = executableElement.getReturnType(); - List idsRefs = helper.extractAnnotationFieldRefs(holder, element, IRClass.Res.ID, true); + List idsRefs = helper.extractAnnotationFieldRefs(processHolder, element, IRClass.Res.ID, true); - JDefinedClass listenerAnonymousClass = holder.codeModel().anonymousClass(getListenerClass()); + JDefinedClass listenerAnonymousClass = codeModel().anonymousClass(getListenerClass()); JMethod listenerMethod = createListenerMethod(listenerAnonymousClass); listenerMethod.annotate(Override.class); @@ -134,18 +131,6 @@ protected JType getViewClass() { return classes().VIEW; } - protected ProcessHolder.Classes classes() { - return holder.classes(); - } - - protected JCodeModel codeModel() { - return holder.codeModel(); - } - - protected JClass refClass(String qualifiedClassName) { - return holder.refClass(qualifiedClassName); - } - protected String getMethodName() { return methodName; } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractSeekBarTouchHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractSeekBarTouchHandler.java index af3a81e0e8..ffaf94db5e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractSeekBarTouchHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AbstractSeekBarTouchHandler.java @@ -71,7 +71,7 @@ public void validate(Element element, AnnotationElements validatedElements, IsVa public void process(Element element, EComponentWithViewSupportHolder holder) throws Exception { String methodName = element.getSimpleName().toString(); - List idsRefs = annotationHelper.extractAnnotationFieldRefs(holder, element, IRClass.Res.ID, true); + List idsRefs = annotationHelper.extractAnnotationFieldRefs(processHolder, element, IRClass.Res.ID, true); for (JFieldRef idRef : idsRefs) { OnSeekBarChangeListenerHolder onSeekBarChangeListenerHolder = holder.getOnSeekBarChangeListenerHolder(idRef); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterTextChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterTextChangeHandler.java index 181959988c..bc2a04577f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterTextChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AfterTextChangeHandler.java @@ -96,7 +96,7 @@ public void process(Element element, EComponentWithViewSupportHolder holder) thr } } - List idsRefs = idAnnotationHelper.extractAnnotationFieldRefs(holder, element, IRClass.Res.ID, true); + List idsRefs = idAnnotationHelper.extractAnnotationFieldRefs(processHolder, element, IRClass.Res.ID, true); for (JFieldRef idRef : idsRefs) { TextWatcherHolder textWatcherHolder = holder.getTextWatcherHolder(idRef, viewParameterType); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandler.java index 6b6d83436c..56ee5e841c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandler.java @@ -21,6 +21,7 @@ import org.androidannotations.holder.GeneratedClassHolder; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.ProcessHolder; import org.androidannotations.rclass.IRClass; public interface AnnotationHandler { @@ -34,4 +35,6 @@ public interface AnnotationHandler { void setAndroidEnvironment(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest); void setValidatedModel(AnnotationElements validatedModel); + + void setProcessHolder(ProcessHolder processHolder); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 0a06fb52d3..da57ce6ad5 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -39,6 +39,7 @@ import org.androidannotations.model.AndroidRes; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; +import org.androidannotations.process.ProcessHolder; import org.androidannotations.rclass.IRClass; public class AnnotationHandlers { @@ -158,6 +159,12 @@ public void setValidatedModel(AnnotationElements validatedModel) { } } + public void setProcessHolder(ProcessHolder processHolder) { + for (AnnotationHandler annotationHandler : annotationHandlers) { + annotationHandler.setProcessHolder(processHolder); + } + } + private boolean traceActivated(ProcessingEnvironment processingEnvironment) { Map options = processingEnvironment.getOptions(); if (options.containsKey(TRACE_OPTION)) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java index 193e336c57..7e71d321f7 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AppHandler.java @@ -49,7 +49,7 @@ public void validate(Element element, AnnotationElements validatedElements, IsVa public void process(Element element, EComponentHolder holder) { String fieldName = element.getSimpleName().toString(); String applicationQualifiedName = element.asType().toString(); - JClass applicationClass = holder.refClass(applicationQualifiedName + ModelConstants.GENERATION_SUFFIX); + JClass applicationClass = refClass(applicationQualifiedName + ModelConstants.GENERATION_SUFFIX); holder.getInitBody().assign(ref(fieldName), applicationClass.staticInvoke(EApplicationHolder.GET_APPLICATION_INSTANCE)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BackgroundHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BackgroundHandler.java index 658f9145a0..137fe06e3e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BackgroundHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BackgroundHandler.java @@ -47,15 +47,15 @@ public BackgroundHandler(ProcessingEnvironment processingEnvironment) { public void process(Element element, EComponentHolder holder) throws Exception { ExecutableElement executableElement = (ExecutableElement) element; - holder.generateApiClass(element, BackgroundExecutor.class); + generateApiClass(element, BackgroundExecutor.class); JMethod delegatingMethod = codeModelHelper.overrideAnnotatedMethod(executableElement, holder); JBlock previousMethodBody = codeModelHelper.removeBody(delegatingMethod); - JDefinedClass anonymousTaskClass = holder.codeModel().anonymousClass(Task.class); + JDefinedClass anonymousTaskClass = codeModel().anonymousClass(Task.class); - JMethod executeMethod = anonymousTaskClass.method(JMod.PUBLIC, holder.codeModel().VOID, "execute"); + JMethod executeMethod = anonymousTaskClass.method(JMod.PUBLIC, codeModel().VOID, "execute"); executeMethod.annotate(Override.class); JBlock runMethodBody = executeMethod.body(); @@ -66,7 +66,7 @@ public void process(Element element, EComponentHolder holder) throws Exception { int delay = annotation.delay(); String serial = annotation.serial(); - JClass backgroundExecutorClass = holder.refClass(BackgroundExecutor.class); + JClass backgroundExecutorClass = refClass(BackgroundExecutor.class); JInvocation newTask = _new(anonymousTaskClass).arg(lit(id)).arg(lit(delay)).arg(lit(serial)); JInvocation executeCall = backgroundExecutorClass.staticInvoke("execute").arg(newTask); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BaseAnnotationHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BaseAnnotationHandler.java index 8e9f5b841e..a3d7bc16d8 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BaseAnnotationHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BaseAnnotationHandler.java @@ -18,6 +18,8 @@ import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JCodeModel; import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.IdAnnotationHelper; import org.androidannotations.helper.IdValidatorHelper; @@ -25,6 +27,7 @@ import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.IsValid; +import org.androidannotations.process.ProcessHolder; import org.androidannotations.rclass.IRClass; public abstract class BaseAnnotationHandler implements AnnotationHandler { @@ -36,6 +39,7 @@ public abstract class BaseAnnotationHandler impl protected AndroidSystemServices androidSystemServices; protected AndroidManifest androidManifest; protected AnnotationElements validatedModel; + protected ProcessHolder processHolder; public BaseAnnotationHandler(Class targetClass, ProcessingEnvironment processingEnvironment) { this(targetClass.getName(), processingEnvironment); @@ -64,6 +68,35 @@ public void setValidatedModel(AnnotationElements validatedModel) { this.validatedModel = validatedModel; } + @Override + public void setProcessHolder(ProcessHolder processHolder) { + this.processHolder = processHolder; + } + + public ProcessingEnvironment processingEnvironment() { + return processHolder.processingEnvironment(); + } + + public ProcessHolder.Classes classes() { + return processHolder.classes(); + } + + public JCodeModel codeModel() { + return processHolder.codeModel(); + } + + public JClass refClass(String fullyQualifiedClassName) { + return processHolder.refClass(fullyQualifiedClassName); + } + + public JClass refClass(Class clazz) { + return processHolder.refClass(clazz); + } + + public void generateApiClass(Element originatingElement, Class apiClass) { + processHolder.generateApiClass(originatingElement, apiClass); + } + @Override public String getTarget() { return target; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java index a7a7a840bb..e41320009a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeanHandler.java @@ -64,7 +64,7 @@ public void process(Element element, EComponentHolder holder) throws Exception { String fieldName = element.getSimpleName().toString(); String typeQualifiedName = elementType.toString(); - JClass injectedClass = holder.refClass(typeQualifiedName + GENERATION_SUFFIX); + JClass injectedClass = refClass(typeQualifiedName + GENERATION_SUFFIX); JFieldRef beanField = ref(fieldName); JBlock block = holder.getInitBody(); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeforeTextChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeforeTextChangeHandler.java index 69ba6b405f..d7e2e627b8 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeforeTextChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/BeforeTextChangeHandler.java @@ -109,7 +109,7 @@ public void process(Element element, EComponentWithViewSupportHolder holder) thr } } - List idsRefs = idAnnotationHelper.extractAnnotationFieldRefs(holder, element, IRClass.Res.ID, true); + List idsRefs = idAnnotationHelper.extractAnnotationFieldRefs(processHolder, element, IRClass.Res.ID, true); for (JFieldRef idRef : idsRefs) { TextWatcherHolder textWatcherHolder = holder.getTextWatcherHolder(idRef, viewParameterType); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java index 4e953864c4..2ef9adbfd2 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/CustomTitleHandler.java @@ -49,9 +49,9 @@ public void validate(Element element, AnnotationElements validatedElements, IsVa public void process(Element element, EActivityHolder holder) { JBlock onViewChangedBody = holder.getOnViewChangedBody(); - JFieldRef contentViewId = annotationHelper.extractAnnotationFieldRefs(holder, element, getTarget(), rClass.get(IRClass.Res.LAYOUT), false).get(0); + JFieldRef contentViewId = annotationHelper.extractAnnotationFieldRefs(processHolder, element, getTarget(), rClass.get(IRClass.Res.LAYOUT), false).get(0); - JFieldRef customTitleFeature = holder.classes().WINDOW.staticRef("FEATURE_CUSTOM_TITLE"); + JFieldRef customTitleFeature = classes().WINDOW.staticRef("FEATURE_CUSTOM_TITLE"); holder.getInitBody().invoke("requestWindowFeature").arg(customTitleFeature); onViewChangedBody.add(holder.getContextRef().invoke("getWindow").invoke("setFeatureInt").arg(customTitleFeature).arg(contentViewId)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EActivityHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EActivityHandler.java index 2997463f38..6a20c03e1b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EActivityHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EActivityHandler.java @@ -62,7 +62,7 @@ public void validate(Element element, AnnotationElements validatedElements, IsVa @Override public void process(Element element, EActivityHolder holder) { - List fieldRefs = annotationHelper.extractAnnotationFieldRefs(holder, element, getTarget(), rClass.get(IRClass.Res.LAYOUT), false); + List fieldRefs = annotationHelper.extractAnnotationFieldRefs(processHolder, element, getTarget(), rClass.get(IRClass.Res.LAYOUT), false); JFieldRef contentViewId = null; if (fieldRefs.size() == 1) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EFragmentHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EFragmentHandler.java index 0dfe6ce04b..772dfe3385 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EFragmentHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EFragmentHandler.java @@ -65,7 +65,7 @@ public void process(Element element, EFragmentHolder holder) { IdAnnotationHelper idAnnotationHelper = new IdAnnotationHelper(processingEnv, getTarget(), rClass); - JFieldRef contentViewId = idAnnotationHelper.extractOneAnnotationFieldRef(holder, element, IRClass.Res.LAYOUT, false); + JFieldRef contentViewId = idAnnotationHelper.extractOneAnnotationFieldRef(processHolder, element, IRClass.Res.LAYOUT, false); if (contentViewId != null) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewGroupHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewGroupHandler.java index 43ad0568d7..7a0a4bdc9b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewGroupHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/EViewGroupHandler.java @@ -63,7 +63,7 @@ public void validate(Element element, AnnotationElements validatedElements, IsVa @Override public void process(Element element, EViewGroupHolder holder) { - JFieldRef contentViewId = annotationHelper.extractOneAnnotationFieldRef(holder, element, IRClass.Res.LAYOUT, false); + JFieldRef contentViewId = annotationHelper.extractOneAnnotationFieldRef(processHolder, element, IRClass.Res.LAYOUT, false); if (contentViewId != null) { holder.getSetContentViewBlock().invoke("inflate").arg(holder.getContextRef()).arg(contentViewId).arg(JExpr._this()); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java index 2cac24cccd..cee14e10c2 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ExtraHandler.java @@ -99,7 +99,7 @@ private JFieldVar createStaticExtraField(HasExtras holder, String extraKey, Stri } else { staticFieldName = CaseHelper.camelCaseToUpperSnakeCase(fieldName + "Extra"); } - return holder.getGeneratedClass().field(PUBLIC | STATIC | FINAL, holder.classes().STRING, staticFieldName, lit(extraKey)); + return holder.getGeneratedClass().field(PUBLIC | STATIC | FINAL, classes().STRING, staticFieldName, lit(extraKey)); } private void injectExtraInComponent(Element element, HasExtras hasExtras, JFieldVar extraKeyStaticField, String fieldName) { @@ -170,9 +170,9 @@ private void createIntentInjectionMethod(Element element, HasIntentBuilder holde JBlock body = method.body(); JInvocation invocation = body.invoke(holder.getIntentField(), "putExtra").arg(extraKeyStaticField); if (castToSerializable) { - invocation.arg(cast(holder.classes().SERIALIZABLE, extraParam)); + invocation.arg(cast(classes().SERIALIZABLE, extraParam)); } else if (castToParcelable) { - invocation.arg(cast(holder.classes().PARCELABLE, extraParam)); + invocation.arg(cast(classes().PARCELABLE, extraParam)); } else { invocation.arg(extraParam); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentArgHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentArgHandler.java index 9c14ce8203..d3673e7ada 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentArgHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentArgHandler.java @@ -84,7 +84,7 @@ private JFieldVar createStaticArgField(EFragmentHolder holder, String argKey, St } else { staticFieldName = CaseHelper.camelCaseToUpperSnakeCase(fieldName + "Arg"); } - return holder.getGeneratedClass().field(PUBLIC | STATIC | FINAL, holder.classes().STRING, staticFieldName, lit(argKey)); + return holder.getGeneratedClass().field(PUBLIC | STATIC | FINAL, classes().STRING, staticFieldName, lit(argKey)); } private void injectArgInComponent(Element element, EFragmentHolder holder, BundleHelper bundleHelper, JFieldVar extraKeyStaticField, String fieldName) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java index 7dec5c628f..8e3e81142c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByIdHandler.java @@ -81,11 +81,11 @@ public void process(Element element, EComponentWithViewSupportHolder holder) { String fieldName = element.getSimpleName().toString(); - JFieldRef idRef = annotationHelper.extractOneAnnotationFieldRef(holder, element, IRClass.Res.ID, true); + JFieldRef idRef = annotationHelper.extractOneAnnotationFieldRef(processHolder, element, IRClass.Res.ID, true); JBlock methodBody = holder.getOnViewChangedBody(); - methodBody.assign(ref(fieldName), cast(holder.refClass(typeQualifiedName), invoke(findFragmentById).arg(idRef))); + methodBody.assign(ref(fieldName), cast(refClass(typeQualifiedName), invoke(findFragmentById).arg(idRef))); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java index 91e1f30cd7..320bd5fc3a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FragmentByTagHandler.java @@ -83,6 +83,6 @@ public void process(Element element, EComponentWithViewSupportHolder holder) { } JBlock methodBody = holder.getOnViewChangedBody(); - methodBody.assign(ref(fieldName), cast(holder.refClass(typeQualifiedName), invoke(findFragmentByTag).arg(lit(tagValue)))); + methodBody.assign(ref(fieldName), cast(refClass(typeQualifiedName), invoke(findFragmentByTag).arg(lit(tagValue)))); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java index 93872630f8..8f51a0418a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FromHtmlHandler.java @@ -62,16 +62,14 @@ public void validate(Element element, AnnotationElements validatedElements, IsVa @Override public void process(Element element, EComponentWithViewSupportHolder holder) { - ProcessHolder.Classes classes = holder.classes(); - String fieldName = element.getSimpleName().toString(); - JFieldRef idRef = annotationHelper.extractOneAnnotationFieldRef(holder, element, IRClass.Res.STRING, true); + JFieldRef idRef = annotationHelper.extractOneAnnotationFieldRef(processHolder, element, IRClass.Res.STRING, true); JBlock methodBody = holder.getOnViewChangedBody(); methodBody // ._if(ref(fieldName).ne(_null())) // ._then() // - .invoke(ref(fieldName), "setText").arg(classes.HTML.staticInvoke("fromHtml").arg(holder.getContextRef().invoke("getString").arg(idRef))); + .invoke(ref(fieldName), "setText").arg(classes().HTML.staticInvoke("fromHtml").arg(holder.getContextRef().invoke("getString").arg(idRef))); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java index b313c2442d..736641bdce 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java @@ -38,7 +38,7 @@ public void validate(Element element, AnnotationElements validatedElements, IsVa @Override public void process(Element element, EActivityHolder holder) { - JFieldRef fullScreen = holder.classes().WINDOW_MANAGER_LAYOUT_PARAMS.staticRef("FLAG_FULLSCREEN"); + JFieldRef fullScreen = classes().WINDOW_MANAGER_LAYOUT_PARAMS.staticRef("FLAG_FULLSCREEN"); holder.getInitBody().invoke("getWindow").invoke("setFlags").arg(fullScreen).arg(fullScreen); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HierarchyViewerSupportHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HierarchyViewerSupportHandler.java index bafbe75b9e..16ea979599 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HierarchyViewerSupportHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HierarchyViewerSupportHandler.java @@ -45,9 +45,9 @@ public void validate(Element element, AnnotationElements validatedElements, IsVa @Override public void process(Element element, EActivityHolder holder) throws Exception { - holder.generateApiClass(element, ViewServer.class); + generateApiClass(element, ViewServer.class); - JInvocation viewServerInvocation = holder.classes().VIEW_SERVER.staticInvoke("get").arg(_this()); + JInvocation viewServerInvocation = classes().VIEW_SERVER.staticInvoke("get").arg(_this()); holder.getOnViewChangedBody().invoke(viewServerInvocation, "addWindow").arg(_this()); holder.getOnDestroyAfterSuperBlock().invoke(viewServerInvocation, "removeWindow").arg(_this()); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java index 44ed4850f0..33a12a1bc2 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/HttpsClientHandler.java @@ -77,9 +77,9 @@ public void process(Element element, EComponentHolder holder) throws Exception { String fieldName = element.getSimpleName().toString(); JBlock methodBody = holder.getInitBody(); - ProcessHolder.Classes classes = holder.classes(); + ProcessHolder.Classes classes = classes(); - JDefinedClass jAnonClass = holder.codeModel().anonymousClass(classes.DEFAULT_HTTP_CLIENT); + JDefinedClass jAnonClass = codeModel().anonymousClass(classes.DEFAULT_HTTP_CLIENT); JMethod method = jAnonClass.method(JMod.PROTECTED, classes.CLIENT_CONNECTION_MANAGER, "createClientConnectionManager"); method.annotate(Override.class); @@ -112,13 +112,13 @@ public void process(Element element, EComponentHolder holder) throws Exception { IRInnerClass rInnerClass = rClass.get(IRClass.Res.RAW); if (useCustomKeyStore) { - JFieldRef rawIdRef = rInnerClass.getIdStaticRef(keyStoreRawId, holder); + JFieldRef rawIdRef = rInnerClass.getIdStaticRef(keyStoreRawId, processHolder); JInvocation jInvRawKey = jVarRes.invoke("openRawResource").arg(rawIdRef); jVarKeyFile = jTryBlock.body().decl(classes.INPUT_STREAM, "inKeystore", jInvRawKey); } if (useCustomTrustStore) { - JFieldRef rawIdRef = rInnerClass.getIdStaticRef(trustStoreRawId, holder); + JFieldRef rawIdRef = rInnerClass.getIdStaticRef(trustStoreRawId, processHolder); JInvocation jInvRawTrust = jVarRes.invoke("openRawResource").arg(rawIdRef); jVarTrstFile = jTryBlock.body().decl(classes.INPUT_STREAM, "inTrustStore", jInvRawTrust); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java index de63301536..2530d003cf 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NoTitleHandler.java @@ -39,7 +39,7 @@ public void validate(Element element, AnnotationElements validatedElements, IsVa @Override public void process(Element element, EActivityHolder holder) { - JFieldRef noTitle = holder.classes().WINDOW.staticRef("FEATURE_NO_TITLE"); + JFieldRef noTitle = classes().WINDOW.staticRef("FEATURE_NO_TITLE"); holder.getInitBody().invoke("requestWindowFeature").arg(noTitle); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NonConfigurationInstanceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NonConfigurationInstanceHandler.java index 9f82dd28c1..aa2a99f9ff 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NonConfigurationInstanceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/NonConfigurationInstanceHandler.java @@ -73,7 +73,7 @@ private void injectInInit(Element element, EActivityHolder holder, String fieldN JBlock initIfNonConfigurationNotNullBlock = holder.getInitIfNonConfigurationNotNullBlock(); JVar initNonConfigurationInstance = holder.getInitNonConfigurationInstance(); initIfNonConfigurationNotNullBlock.assign(ref(fieldName), initNonConfigurationInstance.ref(ncHolderField)); - rebindContextIfBean(element, holder, initIfNonConfigurationNotNullBlock, ncHolderField); + rebindContextIfBean(element, initIfNonConfigurationNotNullBlock, ncHolderField); } private void retainInOnRetain(EActivityHolder holder, String fieldName, JFieldVar ncHolderField) throws JClassAlreadyExistsException { @@ -82,7 +82,7 @@ private void retainInOnRetain(EActivityHolder holder, String fieldName, JFieldVa onRetainNonConfigurationInstanceBindBlock.assign(onRetainNonConfigurationInstance.ref(ncHolderField), ref(fieldName)); } - private void rebindContextIfBean(Element element, EActivityHolder holder, JBlock initIfNonConfigurationNotNullBlock, JFieldVar field) { + private void rebindContextIfBean(Element element, JBlock initIfNonConfigurationNotNullBlock, JFieldVar field) { boolean hasBeanAnnotation = element.getAnnotation(Bean.class) != null; if (hasBeanAnnotation) { @@ -91,7 +91,7 @@ private void rebindContextIfBean(Element element, EActivityHolder holder, JBlock elementType = element.asType(); } String typeQualifiedName = elementType.toString(); - JClass fieldGeneratedBeanClass = holder.refClass(typeQualifiedName + GENERATION_SUFFIX); + JClass fieldGeneratedBeanClass = refClass(typeQualifiedName + GENERATION_SUFFIX); initIfNonConfigurationNotNullBlock.invoke(cast(fieldGeneratedBeanClass, field), "rebind").arg(_this()); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsItemHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsItemHandler.java index 31d11990fe..c69fb27b24 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsItemHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsItemHandler.java @@ -86,7 +86,7 @@ public void process(Element element, HasOptionsMenu holder) { boolean hasItemParameter = parameters.size() == 1; - List idsRefs = annotationHelper.extractAnnotationFieldRefs(holder, element, IRClass.Res.ID, true); + List idsRefs = annotationHelper.extractAnnotationFieldRefs(processHolder, element, IRClass.Res.ID, true); JExpression ifExpr = holder.getOnOptionsItemSelectedItemId().eq(idsRefs.get(0)); for (int i = 1; i < idsRefs.size(); i++) { ifExpr = ifExpr.cor(holder.getOnOptionsItemSelectedItemId().eq(idsRefs.get(i))); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuHandler.java index efd610b158..bad4e49a35 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuHandler.java @@ -61,7 +61,7 @@ public void process(Element element, HasOptionsMenu holder) { JVar menuInflater = holder.getOnCreateOptionsMenuMenuInflaterVar(); JVar menuParam = holder.getOnCreateOptionsMenuMenuParam(); - List fieldRefs = annotationHelper.extractAnnotationFieldRefs(holder, element, IRClass.Res.MENU, false); + List fieldRefs = annotationHelper.extractAnnotationFieldRefs(processHolder, element, IRClass.Res.MENU, false); for (JFieldRef optionsMenuRefId : fieldRefs) { body.invoke(menuInflater, "inflate").arg(optionsMenuRefId).arg(menuParam); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuItemHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuItemHandler.java index 76dd025930..810d89655e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuItemHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OptionsMenuItemHandler.java @@ -67,7 +67,7 @@ public void process(Element element, HasOptionsMenu holder) { JBlock body = holder.getOnCreateOptionsMenuMethodBody(); JVar menuParam = holder.getOnCreateOptionsMenuMenuParam(); - JFieldRef idsRef = annotationHelper.extractOneAnnotationFieldRef(holder, element, IRClass.Res.ID, true); + JFieldRef idsRef = annotationHelper.extractOneAnnotationFieldRef(processHolder, element, IRClass.Res.ID, true); body.assign(ref(fieldName), menuParam.invoke("findItem").arg(idsRef)); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java index d5f77b4ea4..1c15f557ba 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/OrmLiteDaoHandler.java @@ -61,7 +61,7 @@ public void process(Element element, EComponentHolder holder) { String fieldName = element.getSimpleName().toString(); TypeMirror modelObjectTypeMirror = annotationHelper.extractAnnotationParameter(element, "model"); - JExpression modelClass = holder.refClass(modelObjectTypeMirror.toString()).dotclass(); + JExpression modelClass = refClass(modelObjectTypeMirror.toString()).dotclass(); TypeMirror databaseHelperTypeMirror = annotationHelper.extractAnnotationParameter(element, "helper"); JFieldVar databaseHelperRef = holder.getDatabaseHelperRef(databaseHelperTypeMirror); @@ -71,11 +71,11 @@ public void process(Element element, EComponentHolder holder) { JTryBlock tryBlock = initBody._try(); tryBlock.body().assign(ref(fieldName), databaseHelperRef.invoke("getDao").arg(modelClass)); - JCatchBlock catchBlock = tryBlock._catch(holder.classes().SQL_EXCEPTION); + JCatchBlock catchBlock = tryBlock._catch(classes().SQL_EXCEPTION); JVar exception = catchBlock.param("e"); catchBlock.body() // - .staticInvoke(holder.classes().LOG, "e") // + .staticInvoke(classes().LOG, "e") // .arg(holder.getGeneratedClass().name()) // .arg("Could not create DAO " + fieldName) // .arg(exception); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java index d4458a970b..0bae2b5c46 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/PrefHandler.java @@ -82,7 +82,7 @@ public void process(Element element, EComponentHolder holder) { JFieldRef field = JExpr.ref(fieldName); - methodBody.assign(field, JExpr._new(holder.refClass(fieldType)).arg(holder.getContextRef())); + methodBody.assign(field, JExpr._new(refClass(fieldType)).arg(holder.getContextRef())); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ProduceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ProduceHandler.java index 2443918492..1dce2b1ea3 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ProduceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ProduceHandler.java @@ -71,6 +71,6 @@ public void process(Element element, EComponentHolder holder) throws Exception { JMethod delegatingMethod = codeModelHelper.overrideAnnotatedMethod(executableElement, holder); - delegatingMethod.annotate(holder.refClass(PRODUCE)); + delegatingMethod.annotate(refClass(PRODUCE)); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java index 1496cd0ad2..dbffcb6b40 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ResHandler.java @@ -69,13 +69,11 @@ public void validate(Element element, AnnotationElements validatedElements, IsVa @Override public void process(Element element, EComponentHolder holder) { - ProcessHolder.Classes classes = holder.classes(); - String fieldName = element.getSimpleName().toString(); IRClass.Res resInnerClass = androidRes.getRInnerClass(); - JFieldRef idRef = annotationHelper.extractOneAnnotationFieldRef(holder, element, resInnerClass, true); + JFieldRef idRef = annotationHelper.extractOneAnnotationFieldRef(processHolder, element, resInnerClass, true); JBlock methodBody = holder.getInitBody(); @@ -84,13 +82,13 @@ public void process(Element element, EComponentHolder holder) { // Special case for loading animations if (CanonicalNameConstants.ANIMATION.equals(fieldType)) { - methodBody.assign(ref(fieldName), classes.ANIMATION_UTILS.staticInvoke("loadAnimation").arg(holder.getContextRef()).arg(idRef)); + methodBody.assign(ref(fieldName), classes().ANIMATION_UTILS.staticInvoke("loadAnimation").arg(holder.getContextRef()).arg(idRef)); } else { String resourceMethodName = androidRes.getResourceMethodName(); // Special case for @HtmlRes if (element.getAnnotation(HtmlRes.class) != null) { - methodBody.assign(ref(fieldName), classes.HTML.staticInvoke("fromHtml").arg(invoke(holder.getResourcesRef(), resourceMethodName).arg(idRef))); + methodBody.assign(ref(fieldName), classes().HTML.staticInvoke("fromHtml").arg(invoke(holder.getResourcesRef(), resourceMethodName).arg(idRef))); } else { methodBody.assign(ref(fieldName), invoke(holder.getResourcesRef(), resourceMethodName).arg(idRef)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java index 8b1e2f3f37..a904246930 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java @@ -64,7 +64,7 @@ public void validate(Element element, AnnotationElements validatedElements, IsVa public void process(Element element, EActivityHolder holder) { RoboGuiceHolder roboGuiceHolder = holder.getRoboGuiceHolder(); - holder.getGeneratedClass()._implements(holder.classes().INJECTOR_PROVIDER); + holder.getGeneratedClass()._implements(classes().INJECTOR_PROVIDER); JFieldVar scope = roboGuiceHolder.getScopeField(); JFieldVar eventManager = roboGuiceHolder.getEventManagerField(); @@ -90,10 +90,10 @@ private void listenerFields(Element element, EActivityHolder holder) { if (listenerClasses.size() > 0) { int i = 1; for (String listenerClassName : listenerClasses) { - JClass listenerClass = holder.refClass(listenerClassName); + JClass listenerClass = refClass(listenerClassName); JFieldVar listener = holder.getGeneratedClass().field(JMod.PRIVATE, listenerClass, "listener" + i + "_"); listener.annotate(SuppressWarnings.class).param("value", "unused"); - listener.annotate(holder.classes().INJECT); + listener.annotate(classes().INJECT); i++; } } @@ -129,53 +129,51 @@ private List extractListenerClasses(Element activityElement) { } private void beforeCreateMethod(EActivityHolder holder, JFieldVar scope, JFieldVar eventManager, JMethod getInjector) { - ProcessHolder.Classes classes = holder.classes(); - JBlock body = holder.getInitBody(); - JVar injector = body.decl(classes.INJECTOR, "injector_", invoke(getInjector)); - body.assign(scope, invoke(injector, "getInstance").arg(classes.CONTEXT_SCOPE.dotclass())); + JVar injector = body.decl(classes().INJECTOR, "injector_", invoke(getInjector)); + body.assign(scope, invoke(injector, "getInstance").arg(classes().CONTEXT_SCOPE.dotclass())); body.invoke(scope, "enter").arg(_this()); body.invoke(injector, "injectMembers").arg(_this()); - body.assign(eventManager, invoke(injector, "getInstance").arg(classes.EVENT_MANAGER.dotclass())); - fireEvent(eventManager, body, holder.classes().ON_CREATE_EVENT, holder.getInitSavedInstanceParam()); + body.assign(eventManager, invoke(injector, "getInstance").arg(classes().EVENT_MANAGER.dotclass())); + fireEvent(eventManager, body, classes().ON_CREATE_EVENT, holder.getInitSavedInstanceParam()); } private void afterSetContentView(EActivityHolder holder, JFieldVar scope, JFieldVar eventManager) { JBlock onViewChanged = holder.getOnViewChangedBody(); onViewChanged.invoke(scope, "injectViews"); - fireEvent(eventManager, onViewChanged, holder.classes().ON_CONTENT_VIEW_AVAILABLE_EVENT); + fireEvent(eventManager, onViewChanged, classes().ON_CONTENT_VIEW_AVAILABLE_EVENT); } private void onRestartMethod(RoboGuiceHolder holder, JFieldVar scope, JFieldVar eventManager) { JBlock onRestartBeforeSuperBlock = holder.getOnRestartBeforeSuperBlock(); onRestartBeforeSuperBlock.invoke(scope, "enter").arg(_this()); JBlock onRestartAfterSuperBlock = holder.getOnRestartAfterSuperBlock(); - fireEvent(eventManager, onRestartAfterSuperBlock, holder.classes().ON_RESTART_EVENT); + fireEvent(eventManager, onRestartAfterSuperBlock, classes().ON_RESTART_EVENT); } private void onStartMethod(RoboGuiceHolder holder, JFieldVar scope, JFieldVar eventManager) { JBlock onStartBeforeSuperBlock = holder.getOnStartBeforeSuperBlock(); onStartBeforeSuperBlock.invoke(scope, "enter").arg(_this()); JBlock onStartAfterSuperBlock = holder.getOnStartAfterSuperBlock(); - fireEvent(eventManager, onStartAfterSuperBlock, holder.classes().ON_START_EVENT); + fireEvent(eventManager, onStartAfterSuperBlock, classes().ON_START_EVENT); } private void onResumeMethod(RoboGuiceHolder holder, JFieldVar scope, JFieldVar eventManager) { JBlock onResumeBeforeSuperBlock = holder.getOnResumeBeforeSuperBlock(); onResumeBeforeSuperBlock.invoke(scope, "enter").arg(_this()); JBlock onResumeAfterSuperBlock = holder.getOnResumeAfterSuperBlock(); - fireEvent(eventManager, onResumeAfterSuperBlock, holder.classes().ON_RESUME_EVENT); + fireEvent(eventManager, onResumeAfterSuperBlock, classes().ON_RESUME_EVENT); } private void onPauseMethod(RoboGuiceHolder holder, JFieldVar eventManager) { JBlock onPauseAfterSuperBlock = holder.getOnPauseAfterSuperBlock(); - fireEvent(eventManager, onPauseAfterSuperBlock, holder.classes().ON_PAUSE_EVENT); + fireEvent(eventManager, onPauseAfterSuperBlock, classes().ON_PAUSE_EVENT); } private void onNewIntentMethod(RoboGuiceHolder holder, JFieldVar scope, JFieldVar eventManager) { JBlock onNewIntentAfterSuperBlock = holder.getOnNewIntentAfterSuperBlock(); onNewIntentAfterSuperBlock.invoke(scope, "enter").arg(_this()); - fireEvent(eventManager, onNewIntentAfterSuperBlock, holder.classes().ON_NEW_INTENT_EVENT); + fireEvent(eventManager, onNewIntentAfterSuperBlock, classes().ON_NEW_INTENT_EVENT); } private void onStopMethod(RoboGuiceHolder holder, JFieldVar scope, JFieldVar eventManager) { @@ -183,7 +181,7 @@ private void onStopMethod(RoboGuiceHolder holder, JFieldVar scope, JFieldVar eve onStopBeforeSuperBlock.invoke(scope, "enter").arg(_this()); JTryBlock tryBlock = onStopBeforeSuperBlock._try(); - fireEvent(eventManager, tryBlock.body(), holder.classes().ON_STOP_EVENT); + fireEvent(eventManager, tryBlock.body(), classes().ON_STOP_EVENT); JBlock finallyBody = tryBlock._finally(); finallyBody.invoke(scope, "exit").arg(_this()); @@ -195,7 +193,7 @@ private void onDestroyMethod(RoboGuiceHolder holder, JFieldVar scope, JFieldVar onDestroyBeforeSuperBlock.invoke(scope, "enter").arg(_this()); JTryBlock tryBlock = onDestroyBeforeSuperBlock._try(); - fireEvent(eventManager, tryBlock.body(), holder.classes().ON_DESTROY_EVENT); + fireEvent(eventManager, tryBlock.body(), classes().ON_DESTROY_EVENT); JBlock finallyBody = tryBlock._finally(); finallyBody.invoke(eventManager, "clear").arg(_this()); @@ -208,12 +206,12 @@ private void onConfigurationChangedMethod(RoboGuiceHolder holder, JFieldVar even JVar currentConfig = holder.getCurrentConfig(); JBlock onConfigurationChangedAfterSuperBlock = holder.getOnConfigurationChangedAfterSuperBlock(); JExpression newConfig = holder.getNewConfig(); - fireEvent(eventManager, onConfigurationChangedAfterSuperBlock, holder.classes().ON_CONFIGURATION_CHANGED_EVENT, currentConfig, newConfig); + fireEvent(eventManager, onConfigurationChangedAfterSuperBlock, classes().ON_CONFIGURATION_CHANGED_EVENT, currentConfig, newConfig); } private void onContentChangedMethod(RoboGuiceHolder holder, JFieldVar eventManager) { JBlock onContentChangedAfterSuperBlock = holder.getOnContentChangedAfterSuperBlock(); - fireEvent(eventManager, onContentChangedAfterSuperBlock, holder.classes().ON_CONTENT_CHANGED_EVENT); + fireEvent(eventManager, onContentChangedAfterSuperBlock, classes().ON_CONTENT_CHANGED_EVENT); } private void onActivityResultMethod(RoboGuiceHolder holder, JFieldVar scope, JFieldVar eventManager) { @@ -225,7 +223,7 @@ private void onActivityResultMethod(RoboGuiceHolder holder, JFieldVar scope, JFi onActivityResultAfterSuperBlock.invoke(scope, "enter").arg(_this()); JTryBlock tryBlock = onActivityResultAfterSuperBlock._try(); - fireEvent(eventManager, tryBlock.body(), holder.classes().ON_ACTIVITY_RESULT_EVENT, requestCode, resultCode, data); + fireEvent(eventManager, tryBlock.body(), classes().ON_ACTIVITY_RESULT_EVENT, requestCode, resultCode, data); JBlock finallyBody = tryBlock._finally(); finallyBody.invoke(scope, "exit").arg(_this()); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java index df060a18d7..9553743adb 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RootContextHanlder.java @@ -60,7 +60,7 @@ public void process(Element element, EBeanHolder holder) { if (CanonicalNameConstants.CONTEXT.equals(typeQualifiedName)) { body.assign(ref(fieldName), contextRef); } else { - JClass extendingContextClass = holder.refClass(typeQualifiedName); + JClass extendingContextClass = refClass(typeQualifiedName); body._if(contextRef._instanceof(extendingContextClass)) // ._then() // .assign(ref(fieldName), cast(extendingContextClass, contextRef)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarProgressChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarProgressChangeHandler.java index c3f6168a27..95016514ad 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarProgressChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SeekBarProgressChangeHandler.java @@ -95,7 +95,7 @@ public void process(Element element, EComponentWithViewSupportHolder holder) thr } } - List idsRefs = annotationHelper.extractAnnotationFieldRefs(holder, element, IRClass.Res.ID, true); + List idsRefs = annotationHelper.extractAnnotationFieldRefs(processHolder, element, IRClass.Res.ID, true); for (JFieldRef idRef : idsRefs) { OnSeekBarChangeListenerHolder onSeekBarChangeListenerHolder = holder.getOnSeekBarChangeListenerHolder(idRef); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SharedPrefHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SharedPrefHandler.java index 6a6b80d2b9..4eeddd95c3 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SharedPrefHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SharedPrefHandler.java @@ -108,27 +108,27 @@ public void validate(Element element, AnnotationElements validatedElements, IsVa @Override public void process(Element element, SharedPrefHolder holder) { - generateApiClasses(element, holder); + generateApiClasses(element); generateConstructor(element, holder); generateFieldMethodAndEditorFieldMethod(element, holder); } - private void generateApiClasses(Element originatingElement, SharedPrefHolder holder) { - holder.generateApiClass(originatingElement, AbstractPrefEditorField.class); - holder.generateApiClass(originatingElement, AbstractPrefField.class); - holder.generateApiClass(originatingElement, BooleanPrefEditorField.class); - holder.generateApiClass(originatingElement, BooleanPrefField.class); - holder.generateApiClass(originatingElement, EditorHelper.class); - holder.generateApiClass(originatingElement, FloatPrefEditorField.class); - holder.generateApiClass(originatingElement, FloatPrefField.class); - holder.generateApiClass(originatingElement, IntPrefEditorField.class); - holder.generateApiClass(originatingElement, IntPrefField.class); - holder.generateApiClass(originatingElement, LongPrefEditorField.class); - holder.generateApiClass(originatingElement, LongPrefField.class); - holder.generateApiClass(originatingElement, SharedPreferencesCompat.class); - holder.generateApiClass(originatingElement, SharedPreferencesHelper.class); - holder.generateApiClass(originatingElement, StringPrefEditorField.class); - holder.generateApiClass(originatingElement, StringPrefField.class); + private void generateApiClasses(Element originatingElement) { + generateApiClass(originatingElement, AbstractPrefEditorField.class); + generateApiClass(originatingElement, AbstractPrefField.class); + generateApiClass(originatingElement, BooleanPrefEditorField.class); + generateApiClass(originatingElement, BooleanPrefField.class); + generateApiClass(originatingElement, EditorHelper.class); + generateApiClass(originatingElement, FloatPrefEditorField.class); + generateApiClass(originatingElement, FloatPrefField.class); + generateApiClass(originatingElement, IntPrefEditorField.class); + generateApiClass(originatingElement, IntPrefField.class); + generateApiClass(originatingElement, LongPrefEditorField.class); + generateApiClass(originatingElement, LongPrefField.class); + generateApiClass(originatingElement, SharedPreferencesCompat.class); + generateApiClass(originatingElement, SharedPreferencesHelper.class); + generateApiClass(originatingElement, StringPrefEditorField.class); + generateApiClass(originatingElement, StringPrefField.class); } private void generateConstructor(Element element, SharedPrefHolder holder) { @@ -166,7 +166,7 @@ private void generateConstructor(Element element, SharedPrefHolder holder) { break; } case APPLICATION_DEFAULT: { - JClass preferenceManagerClass = holder.refClass("android.preference.PreferenceManager"); + JClass preferenceManagerClass = refClass("android.preference.PreferenceManager"); constructorSuperBlock.invoke("super") // .arg(preferenceManagerClass.staticInvoke("getDefaultSharedPreferences") // .arg(contextParam)); @@ -177,9 +177,9 @@ private void generateConstructor(Element element, SharedPrefHolder holder) { private JMethod getLocalClassName(SharedPrefHolder holder) { - JClass stringClass = holder.classes().STRING; + JClass stringClass = classes().STRING; JMethod getLocalClassName = holder.getGeneratedClass().method(PRIVATE | STATIC, stringClass, "getLocalClassName"); - JClass contextClass = holder.classes().CONTEXT; + JClass contextClass = classes().CONTEXT; JVar contextParam = getLocalClassName.param(contextClass, "context"); @@ -189,7 +189,7 @@ private JMethod getLocalClassName(SharedPrefHolder holder) { JVar className = body.decl(stringClass, "className", contextParam.invoke("getClass").invoke("getName")); - JVar packageLen = body.decl(holder.codeModel().INT, "packageLen", packageName.invoke("length")); + JVar packageLen = body.decl(codeModel().INT, "packageLen", packageName.invoke("length")); JExpression condition = className.invoke("startsWith").arg(packageName).not() // .cor(className.invoke("length").lte(packageLen)) // @@ -269,7 +269,7 @@ private void createFieldMethod(SharedPrefHolder holder, ExecutableElement method } private JExpression extractResValue(SharedPrefHolder holder, Element method, IRClass.Res res) { - JFieldRef idRef = annotationHelper.extractOneAnnotationFieldRef(holder, method, DefaultRes.class.getCanonicalName(), res, true); + JFieldRef idRef = annotationHelper.extractOneAnnotationFieldRef(processHolder, method, DefaultRes.class.getCanonicalName(), res, true); String resourceGetMethodName = null; switch (res) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SubscribeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SubscribeHandler.java index d5305339a0..f005dc6cf0 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SubscribeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SubscribeHandler.java @@ -71,6 +71,6 @@ public void process(Element element, EComponentHolder holder) throws Exception { JMethod delegatingMethod = codeModelHelper.overrideAnnotatedMethod(executableElement, holder); - delegatingMethod.annotate(holder.refClass(SUBSCRIBE)); + delegatingMethod.annotate(refClass(SUBSCRIBE)); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java index 088c758130..86ad91525c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/SystemServiceHandler.java @@ -56,6 +56,6 @@ public void process(Element element, EComponentHolder holder) { JBlock methodBody = holder.getInitBody(); - methodBody.assign(ref(fieldName), cast(holder.refClass(fieldTypeQualifiedName), holder.getContextRef().invoke("getSystemService").arg(serviceRef))); + methodBody.assign(ref(fieldName), cast(refClass(fieldTypeQualifiedName), holder.getContextRef().invoke("getSystemService").arg(serviceRef))); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TextChangeHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TextChangeHandler.java index dfc94780c0..bd5e94855b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TextChangeHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TextChangeHandler.java @@ -109,7 +109,7 @@ public void process(Element element, EComponentWithViewSupportHolder holder) thr } } - List idsRefs = idAnnotationHelper.extractAnnotationFieldRefs(holder, element, IRClass.Res.ID, true); + List idsRefs = idAnnotationHelper.extractAnnotationFieldRefs(processHolder, element, IRClass.Res.ID, true); for (JFieldRef idRef : idsRefs) { TextWatcherHolder textWatcherHolder = holder.getTextWatcherHolder(idRef, viewParameterType); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TraceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TraceHandler.java index e49c8dc15c..d5488073ab 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TraceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TraceHandler.java @@ -63,8 +63,6 @@ public void validate(Element element, AnnotationElements validatedElements, IsVa @Override public void process(Element element, EComponentHolder holder) throws Exception { - ProcessHolder.Classes classes = holder.classes(); - JCodeModel codeModel = holder.codeModel(); ExecutableElement executableElement = (ExecutableElement) element; String tag = extractTag(executableElement); @@ -76,20 +74,20 @@ public void process(Element element, EComponentHolder holder) throws Exception { JBlock methodBody = method.body(); - JInvocation isLoggableInvocation = classes.LOG.staticInvoke("isLoggable"); - isLoggableInvocation.arg(JExpr.lit(tag)).arg(logLevelFromInt(level, classes.LOG)); + JInvocation isLoggableInvocation = classes().LOG.staticInvoke("isLoggable"); + isLoggableInvocation.arg(JExpr.lit(tag)).arg(logLevelFromInt(level, classes().LOG)); JConditional ifStatement = methodBody._if(isLoggableInvocation); - JInvocation currentTimeInvoke = classes.SYSTEM.staticInvoke("currentTimeMillis"); + JInvocation currentTimeInvoke = classes().SYSTEM.staticInvoke("currentTimeMillis"); JBlock _thenBody = ifStatement._then(); - JVar startDeclaration = _thenBody.decl(codeModel.LONG, "start", currentTimeInvoke); + JVar startDeclaration = _thenBody.decl(codeModel().LONG, "start", currentTimeInvoke); String methodName = "[" + element.toString() + "]"; // Log In String logMethodName = logMethodNameFromLevel(level); - JInvocation logEnterInvoke = classes.LOG.staticInvoke(logMethodName); + JInvocation logEnterInvoke = classes().LOG.staticInvoke(logMethodName); logEnterInvoke.arg(tag); JExpression enterMessage = JExpr.lit("Entering " + methodName); @@ -102,9 +100,9 @@ public void process(Element element, EComponentHolder holder) throws Exception { JBlock finallyBlock = tryBlock._finally(); - JVar durationDeclaration = finallyBlock.decl(codeModel.LONG, "duration", currentTimeInvoke.minus(startDeclaration)); + JVar durationDeclaration = finallyBlock.decl(codeModel().LONG, "duration", currentTimeInvoke.minus(startDeclaration)); - JInvocation logExitInvoke = classes.LOG.staticInvoke(logMethodName); + JInvocation logExitInvoke = classes().LOG.staticInvoke(logMethodName); logExitInvoke.arg(tag); JExpression exitMessage = JExpr.lit("Exiting " + methodName + ", duration in ms: ").plus(durationDeclaration); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TransactionalHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TransactionalHandler.java index d8ef149509..a13668195c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TransactionalHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/TransactionalHandler.java @@ -63,7 +63,7 @@ public void process(Element element, EComponentHolder holder) { ExecutableElement executableElement = (ExecutableElement) element; String returnTypeName = executableElement.getReturnType().toString(); - JClass returnType = holder.refClass(returnTypeName); + JClass returnType = refClass(returnTypeName); JMethod method = codeModelHelper.overrideAnnotatedMethod(executableElement, holder); codeModelHelper.removeBody(method); @@ -93,13 +93,13 @@ public void process(Element element, EComponentHolder holder) { tryBody._return(result); } - JCatchBlock catchBlock = tryBlock._catch(holder.refClass(RuntimeException.class)); + JCatchBlock catchBlock = tryBlock._catch(refClass(RuntimeException.class)); JVar exceptionParam = catchBlock.param("e"); JBlock catchBody = catchBlock.body(); - JInvocation errorInvoke = catchBody.staticInvoke(holder.classes().LOG, "e"); + JInvocation errorInvoke = catchBody.staticInvoke(classes().LOG, "e"); errorInvoke.arg(holder.getGeneratedClass().name()); errorInvoke.arg("Error in transaction"); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java index 52b702c120..f89e9255b9 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ViewByIdHandler.java @@ -69,9 +69,9 @@ public void process(Element element, EComponentWithViewSupportHolder holder) { TypeMirror uiFieldTypeMirror = element.asType(); String typeQualifiedName = uiFieldTypeMirror.toString(); - JFieldRef idRef = annotationHelper.extractOneAnnotationFieldRef(holder, element, IRClass.Res.ID, true); + JFieldRef idRef = annotationHelper.extractOneAnnotationFieldRef(processHolder, element, IRClass.Res.ID, true); JBlock methodBody = holder.getOnViewChangedBody(); - methodBody.assign(ref(fieldName), cast(holder.refClass(typeQualifiedName), holder.findViewById(idRef))); + methodBody.assign(ref(fieldName), cast(refClass(typeQualifiedName), holder.findViewById(idRef))); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/GetHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/GetHandler.java index f861a3a565..ab75cc0fb3 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/GetHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/GetHandler.java @@ -49,13 +49,13 @@ protected String getUrlSuffix(Element element) { } @Override - protected JExpression getRequestEntity(Element element, RestHolder holder, JBlock methodBody, TreeMap methodParams) { + protected JExpression getRequestEntity(Element element, JBlock methodBody, TreeMap methodParams) { ExecutableElement executableElement = (ExecutableElement) element; String mediaType = restAnnotationHelper.acceptedHeaders(executableElement); if (mediaType != null) { - JClass httpEntity = holder.classes().HTTP_ENTITY; + JClass httpEntity = classes().HTTP_ENTITY; JInvocation newHttpEntityVarCall = JExpr._new(httpEntity.narrow(Object.class)); - JVar httpHeaders = restAnnotationHelper.declareAcceptedHttpHeaders(holder, methodBody, mediaType); + JVar httpHeaders = restAnnotationHelper.declareAcceptedHttpHeaders(processHolder, methodBody, mediaType); newHttpEntityVarCall.arg(httpHeaders); return methodBody.decl(httpEntity.narrow(Object.class), "requestEntity", newHttpEntityVarCall); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PostHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PostHandler.java index aaf735e4ca..8ec89bc19d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PostHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PostHandler.java @@ -49,13 +49,13 @@ protected String getUrlSuffix(Element element) { } @Override - protected JExpression getRequestEntity(Element element, RestHolder holder, JBlock methodBody, TreeMap methodParams) { + protected JExpression getRequestEntity(Element element, JBlock methodBody, TreeMap methodParams) { String mediaType = restAnnotationHelper.acceptedHeaders((ExecutableElement) element); JVar httpRestHeaders = null; if (mediaType != null) { - httpRestHeaders = restAnnotationHelper.declareAcceptedHttpHeaders(holder, methodBody, mediaType); + httpRestHeaders = restAnnotationHelper.declareAcceptedHttpHeaders(processHolder, methodBody, mediaType); } - return restAnnotationHelper.declareHttpEntity(holder, methodBody, methodParams, httpRestHeaders); + return restAnnotationHelper.declareHttpEntity(processHolder, methodBody, methodParams, httpRestHeaders); } protected JExpression getResponseClass(Element element, RestHolder holder) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PutHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PutHandler.java index 29c4e37671..081ba188da 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PutHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/PutHandler.java @@ -51,7 +51,7 @@ protected String getUrlSuffix(Element element) { } @Override - protected JExpression getRequestEntity(Element element, RestHolder holder, JBlock methodBody, TreeMap methodParams) { - return restAnnotationHelper.declareHttpEntity(holder, methodBody, methodParams); + protected JExpression getRequestEntity(Element element, JBlock methodBody, TreeMap methodParams) { + return restAnnotationHelper.declareHttpEntity(processHolder, methodBody, methodParams); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestHandler.java index 10e077e735..d70c20222d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestHandler.java @@ -92,7 +92,7 @@ private void setConverters(Element element, RestHolder holder) { JFieldVar restTemplateField = holder.getRestTemplateField(); JBlock init = holder.getInit().body(); for (DeclaredType converterType : converters) { - JClass converterClass = holder.refClass(converterType.toString()); + JClass converterClass = refClass(converterType.toString()); init.add(invoke(restTemplateField, "getMessageConverters").invoke("add").arg(_new(converterClass))); } } @@ -100,14 +100,14 @@ private void setConverters(Element element, RestHolder holder) { private void setInterceptors(Element element, RestHolder holder) { List interceptors = annotationHelper.extractAnnotationClassArrayParameter(element, getTarget(), "interceptors"); if (interceptors != null) { - JClass listClass = holder.refClass(ARRAYLIST); - JClass clientInterceptorClass = holder.refClass(CLIENT_HTTP_REQUEST_INTERCEPTOR); + JClass listClass = refClass(ARRAYLIST); + JClass clientInterceptorClass = refClass(CLIENT_HTTP_REQUEST_INTERCEPTOR); listClass = listClass.narrow(clientInterceptorClass); JFieldVar restTemplateField = holder.getRestTemplateField(); JBlock init = holder.getInit().body(); init.add(invoke(restTemplateField, "setInterceptors").arg(_new(listClass))); for (DeclaredType interceptorType : interceptors) { - JClass interceptorClass = holder.refClass(interceptorType.toString()); + JClass interceptorClass = refClass(interceptorType.toString()); init.add(invoke(restTemplateField, "getInterceptors").invoke("add").arg(_new(interceptorClass))); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java index 14b9cc85be..de2a9372fa 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java @@ -67,10 +67,10 @@ public void process(Element element, RestHolder holder) { // RestTemplate exchange() method call JInvocation exchangeCall = JExpr.invoke(holder.getRestTemplateField(), "exchange"); exchangeCall.arg(getUrl(element, holder)); - exchangeCall.arg(getHttpMethod(holder)); - exchangeCall.arg(getRequestEntity(element, holder, methodBody, params)); + exchangeCall.arg(getHttpMethod()); + exchangeCall.arg(getRequestEntity(element, methodBody, params)); exchangeCall.arg(getResponseClass(element, holder)); - JExpression urlVariables = getUrlVariables(element, holder, methodBody, params); + JExpression urlVariables = getUrlVariables(element, methodBody, params); if (urlVariables != null) exchangeCall.arg(urlVariables); @@ -97,7 +97,7 @@ protected TreeMap addMethodParams(ExecutableElement executableElem JVar param; if (parameter.asType().getKind().isPrimitive()) { - param = method.param(JType.parse(restHolder.codeModel(), paramType), paramName); + param = method.param(JType.parse(codeModel(), paramType), paramName); } else { JClass parameterClass = codeModelHelper.typeMirrorToJClass(parameter.asType(), restHolder); param = method.param(parameterClass, paramName); @@ -113,14 +113,14 @@ protected JExpression getUrl(Element element, RestHolder restHolder) { protected abstract String getUrlSuffix(Element element); - protected JExpression getHttpMethod(RestHolder holder) { - JClass httpMethod = holder.classes().HTTP_METHOD; + protected JExpression getHttpMethod() { + JClass httpMethod = classes().HTTP_METHOD; String simpleName = getTarget().substring(getTarget().lastIndexOf('.') + 1); String restMethodInCapitalLetters = simpleName.toUpperCase(Locale.ENGLISH); return httpMethod.staticRef(restMethodInCapitalLetters); } - protected JExpression getRequestEntity(Element element, RestHolder restHolder, JBlock methodBody, TreeMap params) { + protected JExpression getRequestEntity(Element element, JBlock methodBody, TreeMap params) { return JExpr._null(); } @@ -128,8 +128,8 @@ protected JExpression getResponseClass(Element element, RestHolder holder) { return JExpr._null(); } - protected JExpression getUrlVariables(Element element, RestHolder holder, JBlock methodBody, TreeMap params) { - return restAnnotationHelper.declareUrlVariables((ExecutableElement) element, holder, methodBody, params); + protected JExpression getUrlVariables(Element element, JBlock methodBody, TreeMap params) { + return restAnnotationHelper.declareUrlVariables((ExecutableElement) element, processHolder, methodBody, params); } protected JInvocation addResultCallMethod(JInvocation exchangeCall, JClass methodReturnClass) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestServiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestServiceHandler.java index 3e9759da83..8e434d659c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestServiceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestServiceHandler.java @@ -58,6 +58,6 @@ public void process(Element element, EComponentHolder holder) { JFieldRef field = JExpr.ref(fieldName); - methodBody.assign(field, JExpr._new(holder.refClass(generatedClassName))); + methodBody.assign(field, JExpr._new(refClass(generatedClassName))); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java index ab353e1e4e..aa93f2542e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java @@ -99,7 +99,7 @@ public Parameter(String name, JClass jClass) { } } - public JMethod overrideAnnotatedMethod(ExecutableElement executableElement, EComponentHolder holder) { + public JMethod overrideAnnotatedMethod(ExecutableElement executableElement, GeneratedClassHolder holder) { String methodName = executableElement.getSimpleName().toString(); @@ -154,7 +154,7 @@ private JMethod findAlreadyGeneratedMethod(JDefinedClass definedClass, String me return null; } - public void callSuperMethod(JMethod superMethod, EComponentHolder holder, JBlock callBlock) { + public void callSuperMethod(JMethod superMethod, GeneratedClassHolder holder, JBlock callBlock) { JExpression activitySuper = holder.getGeneratedClass().staticRef("super"); JInvocation superCall = JExpr.invoke(activitySuper, superMethod); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AnnotationHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AnnotationHelper.java index 52dee18af3..893a74d0e1 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AnnotationHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AnnotationHelper.java @@ -43,6 +43,7 @@ import org.androidannotations.annotations.OptionsItem; import org.androidannotations.annotations.ResId; import org.androidannotations.holder.GeneratedClassHolder; +import org.androidannotations.process.ProcessHolder; import org.androidannotations.rclass.IRInnerClass; import org.androidannotations.rclass.RInnerClass; @@ -155,7 +156,7 @@ public Types getTypeUtils() { * * @see #extractAnnotationResources(Element, String, IRInnerClass, boolean) */ - public List extractAnnotationFieldRefs(GeneratedClassHolder holder, Element element, String annotationName, IRInnerClass rInnerClass, boolean useElementName) { + public List extractAnnotationFieldRefs(ProcessHolder holder, Element element, String annotationName, IRInnerClass rInnerClass, boolean useElementName) { List fieldRefs = new ArrayList(); for (String refQualifiedName : extractAnnotationResources(element, annotationName, rInnerClass, useElementName)) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdAnnotationHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdAnnotationHelper.java index c223dc56ba..b11ab0a14e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdAnnotationHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/IdAnnotationHelper.java @@ -21,6 +21,7 @@ import javax.lang.model.element.Element; import org.androidannotations.holder.GeneratedClassHolder; +import org.androidannotations.process.ProcessHolder; import org.androidannotations.rclass.IRClass; import org.androidannotations.rclass.IRClass.Res; import org.androidannotations.rclass.IRInnerClass; @@ -50,15 +51,15 @@ public List extractAnnotationResources(Element element, Res res, boolean return super.extractAnnotationResources(element, getTarget(), rClass.get(res), useElementName); } - public List extractAnnotationFieldRefs(GeneratedClassHolder holder, Element element, Res res, boolean useElementName) { + public List extractAnnotationFieldRefs(ProcessHolder holder, Element element, Res res, boolean useElementName) { return super.extractAnnotationFieldRefs(holder, element, getTarget(), rClass.get(res), useElementName); } - public JFieldRef extractOneAnnotationFieldRef(GeneratedClassHolder holder, Element element, Res res, boolean useElementName) { + public JFieldRef extractOneAnnotationFieldRef(ProcessHolder holder, Element element, Res res, boolean useElementName) { return extractOneAnnotationFieldRef(holder, element, getTarget(), res, useElementName); } - public JFieldRef extractOneAnnotationFieldRef(GeneratedClassHolder holder, Element element, String annotationName, Res res, boolean useElementName) { + public JFieldRef extractOneAnnotationFieldRef(ProcessHolder holder, Element element, String annotationName, Res res, boolean useElementName) { List jFieldRefs = extractAnnotationFieldRefs(holder, element, annotationName, rClass.get(res), useElementName); if (jFieldRefs.size() == 1) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/RestAnnotationHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/RestAnnotationHelper.java index 1c74a4b125..c5c00b881f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/RestAnnotationHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/RestAnnotationHelper.java @@ -52,6 +52,7 @@ import com.sun.codemodel.JInvocation; import com.sun.codemodel.JType; import com.sun.codemodel.JVar; +import org.androidannotations.process.ProcessHolder; public class RestAnnotationHelper extends TargetAnnotationHelper { @@ -128,7 +129,7 @@ public Set extractUrlVariableNames(ExecutableElement element) { return variableNames; } - public JVar declareUrlVariables(ExecutableElement element, RestHolder holder, JBlock methodBody, TreeMap methodParams) { + public JVar declareUrlVariables(ExecutableElement element, ProcessHolder holder, JBlock methodBody, TreeMap methodParams) { Set urlVariables = extractUrlVariableNames(element); JClass hashMapClass = holder.refClass(HashMap.class).narrow(String.class, Object.class); if (!urlVariables.isEmpty()) { @@ -155,7 +156,7 @@ public String acceptedHeaders(ExecutableElement executableElement) { } } - public JVar declareAcceptedHttpHeaders(RestHolder holder, JBlock body, String mediaType) { + public JVar declareAcceptedHttpHeaders(ProcessHolder holder, JBlock body, String mediaType) { JClass httpHeadersClass = holder.classes().HTTP_HEADERS; JClass collectionsClass = holder.classes().COLLECTIONS; JClass mediaTypeClass = holder.classes().MEDIA_TYPE; @@ -167,11 +168,11 @@ public JVar declareAcceptedHttpHeaders(RestHolder holder, JBlock body, String me return httpHeadersVar; } - public JExpression declareHttpEntity(RestHolder holder, JBlock body, TreeMap methodParams) { + public JExpression declareHttpEntity(ProcessHolder holder, JBlock body, TreeMap methodParams) { return declareHttpEntity(holder, body, methodParams, null); } - public JExpression declareHttpEntity(RestHolder holder, JBlock body, TreeMap methodParams, JVar httpHeaders) { + public JExpression declareHttpEntity(ProcessHolder holder, JBlock body, TreeMap methodParams, JVar httpHeaders) { JVar entitySentToServer = null; JType entityType = holder.refClass(Object.class); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/BaseGeneratedClassHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/BaseGeneratedClassHolder.java index 4630871e8a..91880f0b29 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/BaseGeneratedClassHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/BaseGeneratedClassHolder.java @@ -19,7 +19,6 @@ import static com.sun.codemodel.JMod.PUBLIC; import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; import javax.lang.model.element.TypeElement; import org.androidannotations.helper.ModelConstants; @@ -89,9 +88,4 @@ public JClass refClass(Class clazz) { public JDefinedClass definedClass(String fullyQualifiedClassName) { return processHolder.definedClass(fullyQualifiedClassName); } - - @Override - public void generateApiClass(Element originatingElement, Class apiClass) { - processHolder.generateApiClass(originatingElement, apiClass); - } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/GeneratedClassHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/GeneratedClassHolder.java index 4e920cb12d..bab7084b01 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/GeneratedClassHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/GeneratedClassHolder.java @@ -30,17 +30,15 @@ public interface GeneratedClassHolder { TypeElement getAnnotatedElement(); - public ProcessingEnvironment processingEnvironment(); + ProcessingEnvironment processingEnvironment(); - public ProcessHolder.Classes classes(); + ProcessHolder.Classes classes(); - public JCodeModel codeModel(); + JCodeModel codeModel(); - public JClass refClass(String fullyQualifiedClassName); + JClass refClass(String fullyQualifiedClassName); - public JClass refClass(Class clazz); + JClass refClass(Class clazz); - public JDefinedClass definedClass(String fullyQualifiedClassName); - - public void generateApiClass(Element originatingElement, Class apiClass); + JDefinedClass definedClass(String fullyQualifiedClassName); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/InstanceStateHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/InstanceStateHolder.java index b9fa27310f..eddc96361b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/InstanceStateHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/InstanceStateHolder.java @@ -21,7 +21,6 @@ import static com.sun.codemodel.JMod.PUBLIC; import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; import javax.lang.model.element.TypeElement; import org.androidannotations.process.ProcessHolder; @@ -141,9 +140,4 @@ public JClass refClass(Class clazz) { public JDefinedClass definedClass(String fullyQualifiedClassName) { return holder.definedClass(fullyQualifiedClassName); } - - @Override - public void generateApiClass(Element originatingElement, Class apiClass) { - holder.generateApiClass(originatingElement, apiClass); - } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java index 3b0ef07c48..8ff7f57cc0 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java @@ -46,10 +46,6 @@ public RoboGuiceHolder(EActivityHolder holder) { this.holder = holder; } - public ProcessHolder.Classes classes() { - return holder.classes(); - } - public JFieldVar getEventManagerField() { if (eventManager == null) { holder.setEventManagerField(); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ModelProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ModelProcessor.java index 9f7bd7382a..5c76cad569 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ModelProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/process/ModelProcessor.java @@ -64,6 +64,8 @@ public ProcessResult process(AnnotationElements validatedModel) throws Exception ProcessHolder processHolder = new ProcessHolder(processingEnv); + annotationHandlers.setProcessHolder(processHolder); + for (GeneratingAnnotationHandler generatingAnnotationHandler : annotationHandlers.getGenerating()) { String annotationName = generatingAnnotationHandler.getTarget(); Set annotatedElements = validatedModel.getRootAnnotatedElements(annotationName); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/CoumpoundInnerClass.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/CoumpoundInnerClass.java index d6fba13787..6e78ee5622 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/CoumpoundInnerClass.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/CoumpoundInnerClass.java @@ -15,9 +15,8 @@ */ package org.androidannotations.rclass; -import org.androidannotations.holder.GeneratedClassHolder; - import com.sun.codemodel.JFieldRef; +import org.androidannotations.process.ProcessHolder; public class CoumpoundInnerClass implements IRInnerClass { @@ -58,7 +57,7 @@ public String getIdQualifiedName(String name) { } @Override - public JFieldRef getIdStaticRef(Integer idValue, GeneratedClassHolder holder) { + public JFieldRef getIdStaticRef(Integer idValue, ProcessHolder holder) { JFieldRef idStaticRef = rInnerClass.getIdStaticRef(idValue, holder); if (idStaticRef == null) { idStaticRef = androidRInnerClass.getIdStaticRef(idValue, holder); @@ -67,7 +66,7 @@ public JFieldRef getIdStaticRef(Integer idValue, GeneratedClassHolder holder) { } @Override - public JFieldRef getIdStaticRef(String name, GeneratedClassHolder holder) { + public JFieldRef getIdStaticRef(String name, ProcessHolder holder) { JFieldRef idStaticRef = rInnerClass.getIdStaticRef(name, holder); if (idStaticRef == null) { idStaticRef = androidRInnerClass.getIdStaticRef(name, holder); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/IRInnerClass.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/IRInnerClass.java index fcbe2f48dd..d0b4a4be95 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/IRInnerClass.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/IRInnerClass.java @@ -15,9 +15,8 @@ */ package org.androidannotations.rclass; -import org.androidannotations.holder.GeneratedClassHolder; - import com.sun.codemodel.JFieldRef; +import org.androidannotations.process.ProcessHolder; public interface IRInnerClass { @@ -29,9 +28,9 @@ public interface IRInnerClass { String getIdQualifiedName(String name); - JFieldRef getIdStaticRef(Integer idValue, GeneratedClassHolder holder); + JFieldRef getIdStaticRef(Integer idValue, ProcessHolder holder); - JFieldRef getIdStaticRef(String name, GeneratedClassHolder holder); + JFieldRef getIdStaticRef(String name, ProcessHolder holder); final IRInnerClass EMPTY_R_INNER_CLASS = new RInnerClass(null); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/RInnerClass.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/RInnerClass.java index 19418dd8cb..173961ca20 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/RInnerClass.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/RInnerClass.java @@ -28,10 +28,10 @@ import javax.lang.model.util.ElementFilter; import org.androidannotations.helper.CaseHelper; -import org.androidannotations.holder.GeneratedClassHolder; import com.sun.codemodel.JClass; import com.sun.codemodel.JFieldRef; +import org.androidannotations.process.ProcessHolder; public class RInnerClass implements IRInnerClass { @@ -105,18 +105,18 @@ public String getIdQualifiedName(String name) { } @Override - public JFieldRef getIdStaticRef(Integer idValue, GeneratedClassHolder holder) { + public JFieldRef getIdStaticRef(Integer idValue, ProcessHolder holder) { String layoutFieldQualifiedName = getIdQualifiedName(idValue); return extractIdStaticRef(holder, layoutFieldQualifiedName); } @Override - public JFieldRef getIdStaticRef(String name, GeneratedClassHolder holder) { + public JFieldRef getIdStaticRef(String name, ProcessHolder holder) { String layoutFieldQualifiedName = getIdQualifiedName(name); return extractIdStaticRef(holder, layoutFieldQualifiedName); } - public static JFieldRef extractIdStaticRef(GeneratedClassHolder holder, String layoutFieldQualifiedName) { + public static JFieldRef extractIdStaticRef(ProcessHolder holder, String layoutFieldQualifiedName) { if (layoutFieldQualifiedName != null) { int fieldSuffix = layoutFieldQualifiedName.lastIndexOf('.'); String fieldName = layoutFieldQualifiedName.substring(fieldSuffix + 1); From 6dc7a83d1f04b05373d96952fe4cdb12d2d9d126 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Tue, 2 Jul 2013 14:08:35 +0200 Subject: [PATCH 78/86] Fix bad generated code by FullscreenHandler --- .../handler/FullscreenHandler.java | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java index 736641bdce..5ca87c04d0 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/FullscreenHandler.java @@ -15,15 +15,17 @@ */ package org.androidannotations.handler; -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; - +import com.sun.codemodel.JFieldRef; +import com.sun.codemodel.JInvocation; import org.androidannotations.annotations.Fullscreen; import org.androidannotations.holder.EActivityHolder; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.IsValid; -import com.sun.codemodel.JFieldRef; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + +import static com.sun.codemodel.JExpr.invoke; public class FullscreenHandler extends BaseAnnotationHandler { @@ -39,6 +41,7 @@ public void validate(Element element, AnnotationElements validatedElements, IsVa @Override public void process(Element element, EActivityHolder holder) { JFieldRef fullScreen = classes().WINDOW_MANAGER_LAYOUT_PARAMS.staticRef("FLAG_FULLSCREEN"); - holder.getInitBody().invoke("getWindow").invoke("setFlags").arg(fullScreen).arg(fullScreen); + JInvocation setFlagsInvocation = invoke(invoke("getWindow"), "setFlags").arg(fullScreen).arg(fullScreen); + holder.getInitBody().add(setFlagsInvocation); } } From 0414900c663e4dbac377b7bd9e217bfa667933ed Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Tue, 2 Jul 2013 14:42:40 +0200 Subject: [PATCH 79/86] Fix missing setContentView in activities --- .../java/org/androidannotations/holder/EActivityHolder.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java index 4fd27c34e0..4b33e19d34 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java @@ -91,6 +91,7 @@ public EActivityHolder(ProcessHolder processHolder, TypeElement annotatedElement super(processHolder, annotatedElement); instanceStateHolder = new InstanceStateHolder(this); onActivityResultHolder = new OnActivityResultHolder(this); + setSetContentView(); createIntentBuilder(); handleBackPressed(); } @@ -307,6 +308,8 @@ public JMethod getSetContentViewLayout() { } private void setSetContentView() { + getOnCreate(); + String setContentViewMethodName; if (usesGreenDroid()) { setContentViewMethodName = "setActionBarContentView"; From 498daa90ed0c5c79856c73b523421ab4f2301ed4 Mon Sep 17 00:00:00 2001 From: Yoann Delouis Date: Mon, 15 Jul 2013 15:37:51 +0200 Subject: [PATCH 80/86] Fix non null HttpEntity in Rest requests --- .../org/androidannotations/helper/RestAnnotationHelper.java | 2 +- .../main/java/org/androidannotations/holder/RestHolder.java | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/RestAnnotationHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/RestAnnotationHelper.java index 2c5f034f0c..e26d52c768 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/RestAnnotationHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/RestAnnotationHelper.java @@ -291,7 +291,7 @@ public JExpression declareHttpEntity(ProcessHolder holder, JBlock body, TreeMap< if (httpHeaders != null) { newHttpEntityVarCall.arg(httpHeaders); } else if (entitySentToServer == null) { - newHttpEntityVarCall.arg(JExpr._null()); + return JExpr._null(); } return body.decl(narrowedHttpEntity, "requestEntity", newHttpEntityVarCall); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RestHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RestHolder.java index 6e2f9d86c1..5585723e92 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RestHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RestHolder.java @@ -292,7 +292,7 @@ private void setAvailableHeadersField() { JClass stringClass = classes().STRING; JClass mapClass = classes().HASH_MAP.narrow(stringClass, stringClass); availableHeadersField = getGeneratedClass().field(JMod.PRIVATE, mapClass, "availableHeaders"); - init.body().assign(availableHeadersField, _new(classes().HASH_MAP)); + init.body().assign(availableHeadersField, _new(mapClass)); } public JFieldVar getAvailableCookiesField() { @@ -306,7 +306,7 @@ private void setAvailableCookiesField() { JClass stringClass = classes().STRING; JClass mapClass = classes().HASH_MAP.narrow(stringClass, stringClass); availableCookiesField = getGeneratedClass().field(JMod.PRIVATE, mapClass, "availableCookies"); - init.body().assign(availableCookiesField, _new(classes().HASH_MAP)); + init.body().assign(availableCookiesField, _new(mapClass)); } public JFieldVar getAuthenticationField() { From cce0a2cf0e1d22c871add267b40a501159e6b2ca Mon Sep 17 00:00:00 2001 From: yDelouis Date: Sun, 8 Dec 2013 20:46:35 +0100 Subject: [PATCH 81/86] Add missing licenses --- .../exception/ProcessingException.java | 15 +++++++++++++++ .../androidannotations/helper/ErrorHelper.java | 15 +++++++++++++++ .../androidannotations-version.properties | 16 ++++++++++++++++ .../helper/CaseHelperTest.java | 15 +++++++++++++++ .../functional-test-1-5/AndroidManifest.xml | 2 ++ .../test15/efragment/StartActivityFragment.java | 15 +++++++++++++++ .../efragment/StartActivityFragmentSupport.java | 15 +++++++++++++++ 7 files changed, 93 insertions(+) diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/exception/ProcessingException.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/exception/ProcessingException.java index fde33fd53a..d087c7ad60 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/exception/ProcessingException.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/exception/ProcessingException.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.exception; import javax.lang.model.element.Element; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ErrorHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ErrorHelper.java index d55c3bb87f..8b31a10c5c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ErrorHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/ErrorHelper.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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 java.io.BufferedReader; diff --git a/AndroidAnnotations/androidannotations/src/main/resources/androidannotations-version.properties b/AndroidAnnotations/androidannotations/src/main/resources/androidannotations-version.properties index e5683df88c..46d482f4cf 100644 --- a/AndroidAnnotations/androidannotations/src/main/resources/androidannotations-version.properties +++ b/AndroidAnnotations/androidannotations/src/main/resources/androidannotations-version.properties @@ -1 +1,17 @@ +# +# Copyright (C) 2010-2013 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. +# + version=${project.version} \ No newline at end of file diff --git a/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/helper/CaseHelperTest.java b/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/helper/CaseHelperTest.java index 15f1c60aa6..ee9e809da9 100644 --- a/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/helper/CaseHelperTest.java +++ b/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/helper/CaseHelperTest.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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 junit.framework.Assert; diff --git a/AndroidAnnotations/functional-test-1-5/AndroidManifest.xml b/AndroidAnnotations/functional-test-1-5/AndroidManifest.xml index ea5df88fd4..36eba61248 100644 --- a/AndroidAnnotations/functional-test-1-5/AndroidManifest.xml +++ b/AndroidAnnotations/functional-test-1-5/AndroidManifest.xml @@ -1,5 +1,6 @@ Date: Tue, 10 Dec 2013 15:18:32 +0100 Subject: [PATCH 82/86] Fix log not done inside runnable for @Background and @UIThread --- .../handler/AnnotationHandlers.java | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java index 6d48c3a5f1..e06c337f3a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/AnnotationHandlers.java @@ -110,8 +110,6 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new ServiceActionHandler(processingEnvironment)); add(new SubscribeHandler(processingEnvironment)); add(new ProduceHandler(processingEnvironment)); - add(new UiThreadHandler(processingEnvironment)); - add(new BackgroundHandler(processingEnvironment)); add(new InstanceStateHandler(processingEnvironment)); add(new HttpsClientHandler(processingEnvironment)); add(new OnActivityResultHandler(processingEnvironment)); @@ -122,9 +120,12 @@ public AnnotationHandlers(ProcessingEnvironment processingEnvironment) { add(new AfterInjectHandler(processingEnvironment)); add(new AfterViewsHandler(processingEnvironment)); - if (traceActivated(processingEnvironment)) { - add(new TraceHandler(processingEnvironment)); - } + if (traceActivated(processingEnvironment)) { + add(new TraceHandler(processingEnvironment)); + } + /* UIThreadHandler and BackgroundHandler must be after TraceHandler */ + add(new UiThreadHandler(processingEnvironment)); + add(new BackgroundHandler(processingEnvironment)); } private void add(AnnotationHandler annotationHandler) { From 516cb96141b678047b99ce5a04cab548a224b7be Mon Sep 17 00:00:00 2001 From: yDelouis Date: Tue, 10 Dec 2013 15:26:04 +0100 Subject: [PATCH 83/86] Fix missing return statement in onHandleIntent() --- .../androidannotations/handler/ServiceActionHandler.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ServiceActionHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ServiceActionHandler.java index 0817d7ac08..eb1f46ff3c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ServiceActionHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/ServiceActionHandler.java @@ -96,9 +96,6 @@ private void addActionInOnHandleIntent(EIntentServiceHolder holder, ExecutableEl JVar extras = callActionBlock.decl(classes().BUNDLE, "extras"); extras.init(holder.getOnHandleIntentIntent().invoke("getExtras")); JBlock extrasNotNullBlock = callActionBlock._if(extras.ne(_null()))._then(); - callActionBlock = extrasNotNullBlock; - - List extraFields = new ArrayList(); // Extras params for (VariableElement param : methodParameters) { @@ -123,8 +120,11 @@ private void addActionInOnHandleIntent(EIntentServiceHolder holder, ExecutableEl JVar extraField = extrasNotNullBlock.decl(extraParamClass, extraParamName, getExtraExpression); callActionInvocation.arg(extraField); } + extrasNotNullBlock.add(callActionInvocation); + } else { + callActionBlock.add(callActionInvocation); } - callActionBlock.add(callActionInvocation); + callActionBlock._return(); } private void addActionToIntentBuilder(EIntentServiceHolder holder, ExecutableElement executableElement, String methodName, JFieldVar actionKeyField) { From 1bed539336a755753de8949c4207cb110cab9fa3 Mon Sep 17 00:00:00 2001 From: yDelouis Date: Tue, 10 Dec 2013 15:45:21 +0100 Subject: [PATCH 84/86] Fix bad request entity in rest methods --- .../handler/rest/RestMethodHandler.java | 3 ++- .../helper/RestAnnotationHelper.java | 16 ++++++++++++---- 2 files changed, 14 insertions(+), 5 deletions(-) diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java index bbd7618007..16dab902c0 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java @@ -135,7 +135,8 @@ protected JExpression getHttpMethod() { protected JExpression getRequestEntity(ExecutableElement element, RestHolder holder, JBlock methodBody, TreeMap params) { JVar httpHeaders = restAnnotationHelper.declareHttpHeaders(element, holder, methodBody); - return restAnnotationHelper.declareHttpEntity(processHolder, methodBody, params, httpHeaders); + JVar entitySentToServer = restAnnotationHelper.getEntitySentToServer(element, params); + return restAnnotationHelper.declareHttpEntity(processHolder, methodBody, entitySentToServer, httpHeaders); } protected JExpression getResponseClass(Element element, RestHolder holder) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/RestAnnotationHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/RestAnnotationHelper.java index e26d52c768..6a1944da5c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/RestAnnotationHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/RestAnnotationHelper.java @@ -267,12 +267,20 @@ public JVar declareHttpHeaders(ExecutableElement executableElement, RestHolder h return httpHeadersVar; } - public JExpression declareHttpEntity(ProcessHolder holder, JBlock body, TreeMap methodParams, JVar httpHeaders) { - JVar entitySentToServer = null; + public JVar getEntitySentToServer(ExecutableElement element, TreeMap params) { + Set urlVariables = extractUrlVariableNames(element); + for (String paramName : params.keySet()) { + if (!urlVariables.contains(paramName)) { + return params.get(paramName); + } + } + return null; + } + + public JExpression declareHttpEntity(ProcessHolder holder, JBlock body, JVar entitySentToServer, JVar httpHeaders) { JType entityType = holder.refClass(Object.class); - if (!methodParams.isEmpty()) { - entitySentToServer = methodParams.firstEntry().getValue(); + if (entitySentToServer != null) { entityType = entitySentToServer.type(); if (entityType.isPrimitive()) { // Don't narrow primitive types... From ea91f41eee17977162407e90be2871cf6f3aa6f5 Mon Sep 17 00:00:00 2001 From: yDelouis Date: Tue, 10 Dec 2013 16:22:19 +0100 Subject: [PATCH 85/86] Fix onStop and onDestroy called twice with RoboGuice --- .../handler/RoboGuiceHandler.java | 22 +++++++---- .../helper/APTCodeModelHelper.java | 37 +++++++++++-------- .../holder/EActivityHolder.java | 4 +- .../holder/RoboGuiceHolder.java | 18 ++++----- 4 files changed, 47 insertions(+), 34 deletions(-) diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java index a904246930..8a52128757 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/handler/RoboGuiceHandler.java @@ -31,11 +31,11 @@ import javax.lang.model.element.ExecutableElement; import org.androidannotations.annotations.RoboGuice; +import org.androidannotations.helper.APTCodeModelHelper; import org.androidannotations.holder.EActivityHolder; import org.androidannotations.holder.RoboGuiceHolder; import org.androidannotations.model.AnnotationElements; import org.androidannotations.process.IsValid; -import org.androidannotations.process.ProcessHolder; import com.sun.codemodel.JBlock; import com.sun.codemodel.JClass; @@ -49,6 +49,8 @@ public class RoboGuiceHandler extends BaseAnnotationHandler { + private APTCodeModelHelper codeModelHelper = new APTCodeModelHelper(); + public RoboGuiceHandler(ProcessingEnvironment processingEnvironment) { super(RoboGuice.class, processingEnvironment); } @@ -177,22 +179,25 @@ private void onNewIntentMethod(RoboGuiceHolder holder, JFieldVar scope, JFieldVa } private void onStopMethod(RoboGuiceHolder holder, JFieldVar scope, JFieldVar eventManager) { - JBlock onStopBeforeSuperBlock = holder.getOnStopBeforeSuperBlock(); - onStopBeforeSuperBlock.invoke(scope, "enter").arg(_this()); + JBlock onStopBlock = new JBlock(false, false); + onStopBlock.invoke(scope, "enter").arg(_this()); - JTryBlock tryBlock = onStopBeforeSuperBlock._try(); + JTryBlock tryBlock = onStopBlock._try(); fireEvent(eventManager, tryBlock.body(), classes().ON_STOP_EVENT); JBlock finallyBody = tryBlock._finally(); finallyBody.invoke(scope, "exit").arg(_this()); finallyBody.invoke(_super(), "onStop"); + + JMethod onStop = holder.getOnStop(); + codeModelHelper.replaceSuperCall(onStop, onStopBlock); } private void onDestroyMethod(RoboGuiceHolder holder, JFieldVar scope, JFieldVar eventManager) { - JBlock onDestroyBeforeSuperBlock = holder.getOnDestroyBeforeSuperBlock(); - onDestroyBeforeSuperBlock.invoke(scope, "enter").arg(_this()); + JBlock onDestroyBlock = new JBlock(false, false); + onDestroyBlock.invoke(scope, "enter").arg(_this()); - JTryBlock tryBlock = onDestroyBeforeSuperBlock._try(); + JTryBlock tryBlock = onDestroyBlock._try(); fireEvent(eventManager, tryBlock.body(), classes().ON_DESTROY_EVENT); JBlock finallyBody = tryBlock._finally(); @@ -200,6 +205,9 @@ private void onDestroyMethod(RoboGuiceHolder holder, JFieldVar scope, JFieldVar finallyBody.invoke(scope, "exit").arg(_this()); finallyBody.invoke(scope, "dispose").arg(_this()); finallyBody.invoke(_super(), "onDestroy"); + + JMethod onDestroy = holder.getOnDestroy(); + codeModelHelper.replaceSuperCall(onDestroy, onDestroyBlock); } private void onConfigurationChangedMethod(RoboGuiceHolder holder, JFieldVar eventManager) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java index 1d881658c7..3dfc90c13c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java @@ -16,6 +16,7 @@ package org.androidannotations.helper; +import java.io.StringWriter; import java.lang.reflect.Field; import java.util.ArrayList; import java.util.List; @@ -31,24 +32,10 @@ import javax.lang.model.type.TypeMirror; import javax.lang.model.type.WildcardType; -import org.androidannotations.holder.EBeanHolder; +import com.sun.codemodel.*; import org.androidannotations.holder.EComponentHolder; import org.androidannotations.holder.GeneratedClassHolder; -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -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.JStatement; -import com.sun.codemodel.JType; -import com.sun.codemodel.JVar; - public class APTCodeModelHelper { public JClass typeMirrorToJClass(TypeMirror type, GeneratedClassHolder holder) { @@ -192,6 +179,26 @@ public JBlock removeBody(JMethod method) { return clonedBody; } + public void replaceSuperCall(JMethod method, JBlock replacement) { + String superCallStart = "super."+method.name()+"("; + + JBlock oldBody = removeBody(method); + JBlock newBody = method.body(); + + for (Object content : oldBody.getContents()) { + StringWriter writer = new StringWriter(); + JFormatter formatter = new JFormatter(writer); + JStatement statement = (JStatement) content; + statement.state(formatter); + String statementString = writer.getBuffer().toString(); + if (statementString.startsWith(superCallStart)) { + newBody.add(replacement); + } else { + newBody.add(statement); + } + } + } + public String getIdStringFromIdFieldRef(JFieldRef idRef) { try { Field nameField = JFieldRef.class.getDeclaredField("name"); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java index d7e01b74b3..44ace35d50 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/EActivityHolder.java @@ -189,15 +189,15 @@ protected void setOnStop() { JMethod method = generatedClass.method(JMod.PUBLIC, codeModel().VOID, "onStop"); method.annotate(Override.class); JBlock body = method.body(); - getRoboGuiceHolder().onStopBeforeSuperBlock = body.block(); body.invoke(_super(), method); + getRoboGuiceHolder().onStop = method; } protected void setOnDestroy() { JMethod method = generatedClass.method(JMod.PUBLIC, codeModel().VOID, "onDestroy"); method.annotate(Override.class); JBlock body = method.body(); - getRoboGuiceHolder().onDestroyBeforeSuperBlock = body.block(); + getRoboGuiceHolder().onDestroy = method; body.invoke(_super(), method); onDestroyAfterSuperBlock = body.block(); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java index 8ff7f57cc0..a177ed96f1 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/holder/RoboGuiceHolder.java @@ -15,8 +15,6 @@ */ package org.androidannotations.holder; -import org.androidannotations.process.ProcessHolder; - import com.sun.codemodel.JBlock; import com.sun.codemodel.JFieldVar; import com.sun.codemodel.JMethod; @@ -35,8 +33,8 @@ public class RoboGuiceHolder { protected JBlock onResumeBeforeSuperBlock; protected JBlock onPauseAfterSuperBlock; protected JBlock onNewIntentAfterSuperBlock; - protected JBlock onStopBeforeSuperBlock; - protected JBlock onDestroyBeforeSuperBlock; + protected JMethod onStop; + protected JMethod onDestroy; protected JVar newConfig; protected JVar currentConfig; protected JBlock onConfigurationChangedAfterSuperBlock; @@ -120,18 +118,18 @@ public JBlock getOnNewIntentAfterSuperBlock() { return onNewIntentAfterSuperBlock; } - public JBlock getOnStopBeforeSuperBlock() { - if (onStopBeforeSuperBlock == null) { + public JMethod getOnStop() { + if (onStop == null) { holder.setOnStop(); } - return onStopBeforeSuperBlock; + return onStop; } - public JBlock getOnDestroyBeforeSuperBlock() { - if (onDestroyBeforeSuperBlock == null) { + public JMethod getOnDestroy() { + if (onDestroy == null) { holder.setOnDestroy(); } - return onDestroyBeforeSuperBlock; + return onDestroy; } public JVar getNewConfig() { From fa7fd1388edd4237edbe3547836ad8b3cfad8fb1 Mon Sep 17 00:00:00 2001 From: yDelouis Date: Wed, 11 Dec 2013 09:14:43 +0100 Subject: [PATCH 86/86] Add missing licenses --- .../generation/ActivityIntentFragmentTest.java | 15 +++++++++++++++ .../generation/AndroidManifestMinFroyo.xml | 2 ++ .../generation/AndroidManifestMinJB.xml | 2 ++ .../androidannotations/generation/Fragment.java | 15 +++++++++++++++ .../generation/support/Fragment.java | 15 +++++++++++++++ .../test15/ebean/CyclicSingletonTest.java | 15 +++++++++++++++ .../test15/rest/RequestTestBuilder.java | 15 +++++++++++++++ 7 files changed, 79 insertions(+) diff --git a/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/generation/ActivityIntentFragmentTest.java b/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/generation/ActivityIntentFragmentTest.java index 5b9c39ab1e..addc87d511 100644 --- a/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/generation/ActivityIntentFragmentTest.java +++ b/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/generation/ActivityIntentFragmentTest.java @@ -1,3 +1,18 @@ +/** + * Copyright (C) 2010-2013 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.generation; import java.io.File; diff --git a/AndroidAnnotations/androidannotations/src/test/resources/org/androidannotations/generation/AndroidManifestMinFroyo.xml b/AndroidAnnotations/androidannotations/src/test/resources/org/androidannotations/generation/AndroidManifestMinFroyo.xml index 000a256ef4..41508bcc14 100644 --- a/AndroidAnnotations/androidannotations/src/test/resources/org/androidannotations/generation/AndroidManifestMinFroyo.xml +++ b/AndroidAnnotations/androidannotations/src/test/resources/org/androidannotations/generation/AndroidManifestMinFroyo.xml @@ -1,5 +1,6 @@