@@ -22,13 +22,22 @@
 
 /**
  * Should be used on method that must be run in the Ui thread
- * 
+ *
  * The annotation parameter delay is the delay (in milliseconds) until the
  * method will be executed. The default is 0 (no delay).
- * 
+ *
  */
 @Retention(RetentionPolicy.CLASS)
 @Target(ElementType.METHOD)
 public @interface UiThread {
 	long delay() default 0;
+
+	/**
+	 * If useDirect = true, the method will check first if it is inside the UI
+	 * thread already. If so, it will directly call the method instead of using
+	 * the handler.
+	 *
+	 * @return
+	 */
+	boolean useDirect() default false;
 }
@@ -56,27 +56,34 @@ public String getTarget() {
 	public void process(Element element, JCodeModel codeModel, EBeanHolder holder) throws JClassAlreadyExistsException {
 
 		ExecutableElement executableElement = (ExecutableElement) element;
+		UiThread annotation = element.getAnnotation(UiThread.class);
+		boolean useDirect = annotation.useDirect();
 
 		JMethod delegatingMethod = helper.overrideAnnotatedMethod(executableElement, holder);
+		JBlock clonedBody = null;
 
-		//Need to clone the body to be put in the check. This is done here because the next line
-		//will remove the body from the method.
-		JBlock clonedBody = cloneMethodBody(delegatingMethod);
+		if (useDirect) {
+			// Need to clone the body to be put in the check. This is done here
+			// because the next line
+			// will remove the body from the method.
+			clonedBody = cloneMethodBody(delegatingMethod);
+		}
 
 		JDefinedClass anonymousRunnableClass = helper.createDelegatingAnonymousRunnableClass(holder, delegatingMethod);
 
 		{
-			//Execute Runnable
-			UiThread annotation = element.getAnnotation(UiThread.class);
+			// Execute Runnable
 			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));
 			}
 
-			//Put in the check for the UI thread.
-			addUIThreadCheck(delegatingMethod, clonedBody, codeModel);
+			if (useDirect) {
+				// Put in the check for the UI thread.
+				addUIThreadCheck(delegatingMethod, clonedBody, codeModel);
+			}
 
 			if (delay == 0) {
 				delegatingMethod.body().invoke(holder.handler, "post").arg(_new(anonymousRunnableClass));
@@ -89,8 +96,9 @@ public void process(Element element, JCodeModel codeModel, EBeanHolder holder) t
 
 	/**
 	 * Clone a method body.
-	 *
-	 * @param method the method to clone.
+	 * 
+	 * @param method
+	 *            the method to clone.
 	 * @return A new JBlock containing the method body.
 	 */
 	private JBlock cloneMethodBody(JMethod method) {
@@ -105,26 +113,28 @@ private JBlock cloneMethodBody(JMethod method) {
 
 	/**
 	 * Add the pre-check to see if we are already in the UI thread.
-	 *
+	 * 
 	 * @param delegatingMethod
 	 * @param codeModel
 	 * @throws JClassAlreadyExistsException
 	 */
 	private void addUIThreadCheck(JMethod delegatingMethod, JBlock clonedBody, JCodeModel codeModel) throws JClassAlreadyExistsException {
-		//Get the Thread and Looper class.
+		// Get the Thread and Looper class.
 		JClass tClass = codeModel.ref(Thread.class);
 		JClass lClass = codeModel.ref(Looper.class);
 
-		//invoke the methods.
+		// invoke the methods.
 		JExpression lhs = tClass.staticInvoke(METHOD_CUR_THREAD);
 		JExpression rhs = lClass.staticInvoke(METHOD_MAIN_LOOPER).invoke(METHOD_GET_THREAD);
 
-		//create the conditional and the block.
+		// create the conditional and the block.
 		JConditional con = delegatingMethod.body()._if(JOp.eq(lhs, rhs));
 		JBlock block = con._then();
 
-		//Put the cloned method body in the if() block, this is necessary because the
-		//method may have parameters and a simple super.methodCall() won't work.
+		// Put the cloned method body in the if() block, this is necessary
+		// because the
+		// method may have parameters and a simple super.methodCall() won't
+		// work.
 		for (Object statement : clonedBody.getContents()) {
 			block.add((JStatement) statement);
 		}