Using an executor service instead of a new thread each time an @background method is called. Fixes issue 4. I also had to catch FilerExceptions that happens when creating twice the same file for different rounds...

pyricau · pyricau · commit 98d4f37d6336 · 2011-04-06T12:36:38.000Z
diff --git a/AndroidAnnotations/src/main/java/com/googlecode/androidannotations/AndroidAnnotationProcessor.java b/AndroidAnnotations/src/main/java/com/googlecode/androidannotations/AndroidAnnotationProcessor.java
@@ -169,7 +169,7 @@ private void processThrowing(Set<? extends TypeElement> annotations, RoundEnviro
 
 		AnnotationElements validatedModel = validateAnnotations(extractedModel, rClass, androidSystemServices, androidManifest);
 
-		JCodeModel codeModel = processAnnotations(validatedModel, rClass, androidSystemServices);
+		JCodeModel codeModel = processAnnotations(validatedModel, rClass, androidSystemServices, androidManifest);
 
 		generateSources(codeModel);
 	}
@@ -230,12 +230,12 @@ private ModelValidator buildModelValidator(IRClass rClass, AndroidSystemServices
 		return modelValidator;
 	}
 
-	private JCodeModel processAnnotations(AnnotationElements validatedModel, IRClass rClass, AndroidSystemServices androidSystemServices) {
-		ModelProcessor modelProcessor = buildModelProcessor(rClass, androidSystemServices);
+	private JCodeModel processAnnotations(AnnotationElements validatedModel, IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) {
+		ModelProcessor modelProcessor = buildModelProcessor(rClass, androidSystemServices, androidManifest);
 		return modelProcessor.process(validatedModel);
 	}
 
-	private ModelProcessor buildModelProcessor(IRClass rClass, AndroidSystemServices androidSystemServices) {
+	private ModelProcessor buildModelProcessor(IRClass rClass, AndroidSystemServices androidSystemServices, AndroidManifest androidManifest) {
 		ModelProcessor modelProcessor = new ModelProcessor();
 		modelProcessor.register(new EnhanceProcessor(processingEnv, rClass));
 		modelProcessor.register(new RoboGuiceProcessor());
@@ -251,7 +251,7 @@ private ModelProcessor buildModelProcessor(IRClass rClass, AndroidSystemServices
 		}
 		modelProcessor.register(new UiThreadProcessor());
 		modelProcessor.register(new UiThreadDelayedProcessor());
-		modelProcessor.register(new BackgroundProcessor());
+		modelProcessor.register(new BackgroundProcessor(androidManifest));
 		modelProcessor.register(new TransactionalProcessor());
 		modelProcessor.register(new ExtraProcessor());
 		modelProcessor.register(new SystemServiceProcessor(androidSystemServices));
diff --git a/AndroidAnnotations/src/main/java/com/googlecode/androidannotations/generation/SourceCodewriter.java b/AndroidAnnotations/src/main/java/com/googlecode/androidannotations/generation/SourceCodewriter.java
@@ -4,36 +4,57 @@
 import java.io.OutputStream;
 
 import javax.annotation.processing.Filer;
+import javax.annotation.processing.FilerException;
 import javax.tools.JavaFileObject;
 
 import com.sun.codemodel.CodeWriter;
 import com.sun.codemodel.JPackage;
 
 public class SourceCodewriter extends CodeWriter {
-	
+
 	private final Filer filer;
-	
+
+	private static final VoidOutputStream VOID_OUTPUT_STREAM = new VoidOutputStream();
+
+	private static class VoidOutputStream extends OutputStream {
+		@Override
+		public void write(int arg0) throws IOException {
+			// Do nothing
+		}
+	}
+
 	public SourceCodewriter(Filer filer) {
 		this.filer = filer;
 	}
 
 	@Override
 	public OutputStream openBinary(JPackage pkg, String fileName) throws IOException {
 		String qualifiedClassName = toQualifiedClassName(pkg, fileName);
-		
-		JavaFileObject sourceFile = filer.createSourceFile(qualifiedClassName);
-		
-		return sourceFile.openOutputStream();
+
+		try {
+			JavaFileObject sourceFile = filer.createSourceFile(qualifiedClassName);
+			return sourceFile.openOutputStream();
+		} catch (FilerException e) {
+			/*
+			 * This exception is expected, when some files are created twice. We
+			 * cannot delete existing files, unless using a dirty hack. Files a
+			 * created twice when the same file is created from different
+			 * annotation rounds. Happens when renaming classes, and for
+			 * Background executor.
+			 */
+			return VOID_OUTPUT_STREAM;
+		}
 	}
 
 	private String toQualifiedClassName(JPackage pkg, String fileName) {
 		int suffixPosition = fileName.lastIndexOf('.');
 		String className = fileName.substring(0, suffixPosition);
-		
-		String qualifiedClassName = pkg.name() + "."+className;
+
+		String qualifiedClassName = pkg.name() + "." + className;
 		return qualifiedClassName;
 	}
 
 	@Override
-	public void close() throws IOException {}
+	public void close() throws IOException {
+	}
 }
diff --git a/AndroidAnnotations/src/main/java/com/googlecode/androidannotations/processing/ActivitiesHolder.java b/AndroidAnnotations/src/main/java/com/googlecode/androidannotations/processing/ActivitiesHolder.java
@@ -5,9 +5,14 @@
 
 import javax.lang.model.element.Element;
 
+import com.sun.codemodel.JDefinedClass;
+import com.sun.codemodel.JMethod;
+
 public class ActivitiesHolder {
 
     private Map<Element, ActivityHolder> activityHolders = new HashMap<Element, ActivityHolder>();
+	public JMethod executorMethod;
+	public JDefinedClass backgroundExecutor;
 
     public ActivityHolder create(Element activityElement) {
         ActivityHolder activityHolder = new ActivityHolder();
diff --git a/AndroidAnnotations/src/main/java/com/googlecode/androidannotations/processing/BackgroundProcessor.java b/AndroidAnnotations/src/main/java/com/googlecode/androidannotations/processing/BackgroundProcessor.java
@@ -18,12 +18,15 @@
 import java.lang.annotation.Annotation;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
 
 import javax.lang.model.element.Element;
 import javax.lang.model.element.ExecutableElement;
 import javax.lang.model.element.VariableElement;
 
 import com.googlecode.androidannotations.annotations.Background;
+import com.googlecode.androidannotations.helper.AndroidManifest;
 import com.sun.codemodel.JBlock;
 import com.sun.codemodel.JCatchBlock;
 import com.sun.codemodel.JClass;
@@ -32,6 +35,7 @@
 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;
@@ -40,6 +44,12 @@
 
 public class BackgroundProcessor implements ElementProcessor {
 
+	private final AndroidManifest androidManifest;
+
+	public BackgroundProcessor(AndroidManifest androidManifest) {
+		this.androidManifest = androidManifest;
+	}
+
 	@Override
 	public Class<? extends Annotation> getTarget() {
 		return Background.class;
@@ -50,6 +60,17 @@ public void process(Element element, JCodeModel codeModel, ActivitiesHolder acti
 
 		ActivityHolder holder = activitiesHolder.getEnclosingActivityHolder(element);
 
+		if (activitiesHolder.backgroundExecutor == null) {
+			activitiesHolder.backgroundExecutor = codeModel._class(androidManifest.getApplicationPackage() + ".BackgroundExecutor_");
+
+			JInvocation newCachedThreadPool = codeModel.ref(Executors.class).staticInvoke("newCachedThreadPool");
+
+			JFieldVar executorStaticField = activitiesHolder.backgroundExecutor.field(JMod.STATIC | JMod.PRIVATE | JMod.FINAL, codeModel.ref(Executor.class), "executor", newCachedThreadPool);
+			activitiesHolder.executorMethod = activitiesHolder.backgroundExecutor.method(JMod.PUBLIC | JMod.STATIC, codeModel.VOID, "execute");
+			JVar runnableParam = activitiesHolder.executorMethod.param(Runnable.class, "runnable");
+			activitiesHolder.executorMethod.body().invoke(executorStaticField, "execute").arg(runnableParam);
+		}
+
 		// Method
 		String backgroundMethodName = element.getSimpleName().toString();
 		JMethod backgroundMethod = holder.activity.method(JMod.PUBLIC, codeModel.VOID, backgroundMethodName);
@@ -65,16 +86,16 @@ public void process(Element element, JCodeModel codeModel, ActivitiesHolder acti
 			parameters.add(param);
 		}
 
-		JDefinedClass anonymousThreadClass = codeModel.anonymousClass(Thread.class);
+		JDefinedClass anonymousRunnableClass = codeModel.anonymousClass(Runnable.class);
 
-		JMethod runMethod = anonymousThreadClass.method(JMod.PUBLIC, codeModel.VOID, "run");
+		JMethod runMethod = anonymousRunnableClass.method(JMod.PUBLIC, codeModel.VOID, "run");
 		runMethod.annotate(Override.class);
 
 		JBlock runMethodBody = runMethod.body();
 		JTryBlock runTry = runMethodBody._try();
-		
+
 		JExpression activitySuper = holder.activity.staticRef("super");
-		
+
 		JInvocation superCall = runTry.body().invoke(activitySuper, backgroundMethod);
 		for (JVar param : parameters) {
 			superCall.arg(param);
@@ -93,8 +114,9 @@ public void process(Element element, JCodeModel codeModel, ActivitiesHolder acti
 		runCatch.body().add(errorInvoke);
 
 		JBlock backgroundBody = backgroundMethod.body();
-
-		backgroundBody.add(JExpr._new(anonymousThreadClass).invoke("start"));
-
+		
+		JInvocation executeCall = activitiesHolder.backgroundExecutor.staticInvoke(activitiesHolder.executorMethod).arg(JExpr._new(anonymousRunnableClass));
+		
+		backgroundBody.add(executeCall);
 	}
 }
