Merge merged PR 658 : EnhancedRestClient interfaces

DayS · Dec 16, 2013 · Jun 4, 2013 · May 22, 2013 · Jun 4, 2013 · May 23, 2013
commit 4788b47225d2438787df1f4ba326841301bca624
diff --git a/AndroidAnnotations/androidannotations-api/pom.xml b/AndroidAnnotations/androidannotations-api/pom.xml
@@ -24,6 +24,13 @@
 			<version>1.6_r2</version>
 			<scope>provided</scope>
 		</dependency>
+		<dependency>
+			<!-- spring-android-rest-template is required to use the Rest API -->
+			<groupId>org.springframework.android</groupId>
+			<artifactId>spring-android-rest-template</artifactId>
+			<version>1.0.0.RELEASE</version>
+			<scope>provided</scope>
+		</dependency>
 	</dependencies>
 
 	<build>

diff --git a/...nnotations-api/src/main/java/org/androidannotations/api/rest/RestClientErrorHandling.java b/...nnotations-api/src/main/java/org/androidannotations/api/rest/RestClientErrorHandling.java
@@ -0,0 +1,29 @@
+/**
+ * Copyright (C) 2010-2013 eBusiness Information, Excilys Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed To in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package org.androidannotations.api.rest;
+
+/**
+ * A @Rest interface implementing this interface will automatically have the
+ * implementations of this method generated.
+ */
+public interface RestClientErrorHandling {
+	/**
+	 * Sets the error handler called when a rest error occurs.
+	 * 
+	 * @param handler
+	 */
+	void setRestErrorHandler(RestErrorHandler handler);
+}
diff --git a/...droidannotations-api/src/main/java/org/androidannotations/api/rest/RestClientHeaders.java b/...droidannotations-api/src/main/java/org/androidannotations/api/rest/RestClientHeaders.java
@@ -0,0 +1,72 @@
+/**
+ * Copyright (C) 2010-2013 eBusiness Information, Excilys Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed To in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package org.androidannotations.api.rest;
+
+import org.springframework.http.HttpAuthentication;
+
+/**
+ * A @Rest interface implementing this interface will automatically have the
+ * implementations of these methods generated.
+ */
+public interface RestClientHeaders {
+
+	/**
+	 * Gets a cookie by name.
+	 * 
+	 * @param name
+	 * @return the cookie value.
+	 */
+	String getCookie(String name);
+
+	/**
+	 * Sets a cookie by name.
+	 * 
+	 * @param name
+	 * @param value
+	 */
+	void setCookie(String name, String value);
+
+	/**
+	 * Gets a header by name.
+	 * 
+	 * @param name
+	 * @return the header value.
+	 */
+	String getHeader(String name);
+
+	/**
+	 * Sets a header by name.
+	 * 
+	 * @param name
+	 * @param value
+	 */
+	void setHeader(String name, String value);
+
+	/**
+	 * Sets the authentication object.
+	 * 
+	 * @param auth
+	 */
+	void setAuthentication(HttpAuthentication auth);
+
+	/**
+	 * Sets the basic authentication user/password.
+	 * 
+	 * @param user
+	 * @param password
+	 */
+	void setHttpBasicAuth(String user, String password);
+}
diff --git a/...droidannotations-api/src/main/java/org/androidannotations/api/rest/RestClientRootUrl.java b/...droidannotations-api/src/main/java/org/androidannotations/api/rest/RestClientRootUrl.java
@@ -0,0 +1,37 @@
+/**
+ * Copyright (C) 2010-2013 eBusiness Information, Excilys Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed To in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package org.androidannotations.api.rest;
+
+/**
+ * A @Rest interface implementing this interface will automatically have the
+ * implementations of these methods generated.
+ */
+public interface RestClientRootUrl {
+	/**
+	 * Gets the root URL for the rest service.
+	 * 
+	 * @return String
+	 */
+	String getRootUrl();
+
+	/**
+	 * Sets the root URL for the rest service.
+	 * 
+	 * @param rootUrl
+	 */
+	void setRootUrl(String rootUrl);
+
+}
diff --git a/...droidannotations-api/src/main/java/org/androidannotations/api/rest/RestClientSupport.java b/...droidannotations-api/src/main/java/org/androidannotations/api/rest/RestClientSupport.java
@@ -0,0 +1,38 @@
+/**
+ * Copyright (C) 2010-2013 eBusiness Information, Excilys Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed To in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package org.androidannotations.api.rest;
+
+import org.springframework.web.client.RestTemplate;
+
+/**
+ * A @Rest interface implementing this interface will automatically have the
+ * implementations of these methods generated.
+ */
+public interface RestClientSupport {
+	/**
+	 * Gets the rest template used by the rest service implementation.
+	 * 
+	 * @return RestTemplate
+	 */
+	RestTemplate getRestTemplate();
+
+	/**
+	 * Sets the rest template used by the rest service implementation.
+	 * 
+	 * @param rt
+	 */
+	void setRestTemplate(RestTemplate rt);
+}
diff --git a/...ndroidannotations-api/src/main/java/org/androidannotations/api/rest/RestErrorHandler.java b/...ndroidannotations-api/src/main/java/org/androidannotations/api/rest/RestErrorHandler.java
@@ -0,0 +1,30 @@
+/**
+ * Copyright (C) 2010-2013 eBusiness Information, Excilys Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed To in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package org.androidannotations.api.rest;
+
+import org.springframework.web.client.RestClientException;
+
+/**
+ * This interface is used for handling rest client exceptions.
+ */
+public interface RestErrorHandler {
+	/**
+	 * Called when an exception occurs within the rest client.
+	 * 
+	 * @param e
+	 */
+	void onRestClientExceptionThrown(RestClientException e);
+}
diff --git a/...ons/androidannotations/src/main/java/org/androidannotations/handler/rest/RestHandler.java b/...ons/androidannotations/src/main/java/org/androidannotations/handler/rest/RestHandler.java
@@ -63,7 +63,7 @@ public void validate(Element element, AnnotationElements validatedElements, IsVa
 
 		validatorHelper.isTopLevel(typeElement, valid);
 
-		validatorHelper.doesNotExtendOtherInterfaces(typeElement, valid);
+		validatorHelper.doesNotExtendInvalidInterfaces(typeElement, valid);
 
 		validatorHelper.unannotatedMethodReturnsRestTemplate(typeElement, valid);
 

diff --git a/...droidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java b/...droidannotations/src/main/java/org/androidannotations/handler/rest/RestMethodHandler.java
@@ -83,10 +83,10 @@ public void process(Element element, RestHolder holder) {
 		}
 
 		if (methodReturnVoid && result == null) {
-			methodBody.add(exchangeCall);
+			insertRestTryCatchBlock(holder, methodBody, exchangeCall, methodReturnVoid);
 		} else if (!methodReturnVoid) {
 			returnCall = addResultCallMethod(returnCall, methodReturnClass);
-			methodBody._return(returnCall);
+			insertRestTryCatchBlock(holder, methodBody, returnCall, methodReturnVoid);
 		}
 	}
 
@@ -195,4 +195,41 @@ private JFieldRef setCookies(ExecutableElement executableElement, RestHolder res
 		}
 		return null;
 	}
+
+	/**
+	 * Adds the try/catch around the rest execution code.
+	 *
+	 * If an exception is caught, it will first check if the handler is set. If
+	 * the handler is set, it will call the handler and return null (or nothing
+	 * if void). If the handler isn't set, it will re-throw the exception so
+	 * that it behaves as it did previous to this feature.
+	 */
+	private void insertRestTryCatchBlock(RestHolder holder, JBlock body, JExpression returnCall, boolean methodReturnVoid) {
+		JTryBlock tryBlock = body._try();
+
+		if (methodReturnVoid) {
+			tryBlock.body().add((JInvocation) returnCall);
+		} else {
+			tryBlock.body()._return(returnCall);
+		}
+
+		JCatchBlock jCatch = tryBlock._catch(classes().REST_CLIENT_EXCEPTION);
+
+		JBlock catchBlock = jCatch.body();
+		JConditional conditional = catchBlock._if(JOp.ne(holder.getRestErrorHandlerField(), JExpr._null()));
+		JVar exceptionParam = jCatch.param("e");
+
+		JBlock thenBlock = conditional._then();
+
+		// call the handler method if it was set.
+		thenBlock.add(holder.getRestErrorHandlerField().invoke("onRestClientExceptionThrown").arg(exceptionParam));
+
+		// return null if exception was caught and handled.
+		if (!methodReturnVoid) {
+			thenBlock._return(JExpr._null());
+		}
+
+		// re-throw the exception if handler wasn't set.
+		conditional._else()._throw(exceptionParam);
+	}
 }
diff --git a/...ns/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java b/...ns/androidannotations/src/main/java/org/androidannotations/helper/APTCodeModelHelper.java
@@ -19,12 +19,12 @@
 import java.util.ArrayList;
 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.element.VariableElement;
-import javax.lang.model.type.ArrayType;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.TypeMirror;
-import javax.lang.model.type.WildcardType;
+import javax.lang.model.type.*;
+import javax.lang.model.util.ElementFilter;
 
 import org.androidannotations.holder.EComponentHolder;
 import org.androidannotations.holder.GeneratedClassHolder;
@@ -246,4 +246,84 @@ public JDefinedClass createDelegatingAnonymousRunnableClass(EComponentHolder hol
 
 		return anonymousRunnableClass;
 	}
+
+	/**
+	 * Gets all of the methods of the class and includes the methods of any
+	 * implemented interfaces.
+	 *
+	 * @param typeElement
+	 * @return full list of methods.
+	 */
+	public List<ExecutableElement> getMethods(TypeElement typeElement) {
+		List<? extends Element> enclosedElements = typeElement.getEnclosedElements();
+		List<ExecutableElement> methods = new ArrayList<ExecutableElement>(ElementFilter.methodsIn(enclosedElements));
+
+		// Add methods of the interfaces. These will be valid as they have gone
+		// through the validator.
+		for (TypeMirror iface : typeElement.getInterfaces()) {
+			DeclaredType dt = (DeclaredType) iface;
+			methods.addAll(ElementFilter.methodsIn(dt.asElement().getEnclosedElements()));
+		}
+
+		return methods;
+	}
+
+	public JMethod implementMethod(GeneratedClassHolder holder, List<ExecutableElement> methods, String methodName, String returnType, String... parameterTypes) {
+		// First get the ExecutableElement method object from the util function.
+		ExecutableElement method = getMethod(methods, methodName, returnType, parameterTypes);
+		JMethod jmethod = null;
+
+		if (method != null) {
+			// Get the return type or VOID if none.
+			JType jcReturnType = returnType.equals(TypeKind.VOID.toString()) ? holder.codeModel().VOID : holder.refClass(returnType);
+
+			// Create the implementation and annotate it with the Override
+			// annotation.
+			jmethod = holder.getGeneratedClass().method(JMod.PUBLIC, jcReturnType, method.getSimpleName().toString());
+			jmethod.annotate(Override.class);
+
+			// Create the parameters.
+			for (int i = 0; i < method.getParameters().size(); i++) {
+				VariableElement param = method.getParameters().get(i);
+				jmethod.param(holder.refClass(parameterTypes[i]), param.getSimpleName().toString());
+			}
+		}
+
+		return jmethod;
+	}
+
+	private ExecutableElement getMethod(List<ExecutableElement> methods, String methodName, String returnType, String... parameterTypes) {
+		for (ExecutableElement method : methods) {
+			List<? extends VariableElement> parameters = method.getParameters();
+
+			// Get the method return type or "VOID" if none.
+			String methodReturnType = method.getReturnType().getKind() == TypeKind.VOID ? TypeKind.VOID.toString() : method.getReturnType().toString();
+
+			if (parameters.size() == parameterTypes.length && methodReturnType.equals(returnType)) {
+				if (methodName == null || method.getSimpleName().toString().equals(methodName)) {
+					// At this point, method name, return type and number of
+					// parameters are correct. Now we need to validate the
+					// parameter types.
+					boolean validMethod = true;
+
+					for (int i = 0; i < parameters.size(); i++) {
+						VariableElement param = parameters.get(i);
+
+						if (!param.asType().toString().equals(parameterTypes[i])) {
+							// Parameter type does not match, this is not the
+							// correct method.
+							validMethod = false;
+							break;
+						}
+					}
+
+					if (validMethod) {
+						return method;
+					}
+				}
+			}
+		}
+
+		return null;
+	}
 }
diff --git a/...ndroidannotations/src/main/java/org/androidannotations/helper/CanonicalNameConstants.java b/...ndroidannotations/src/main/java/org/androidannotations/helper/CanonicalNameConstants.java
@@ -131,6 +131,7 @@ public final class CanonicalNameConstants {
 	public static final String CLIENT_HTTP_REQUEST_INTERCEPTOR = "org.springframework.http.client.ClientHttpRequestInterceptor";
 	public static final String HTTP_AUTHENTICATION = "org.springframework.http.HttpAuthentication";
 	public static final String HTTP_BASIC_AUTHENTICATION = "org.springframework.http.HttpBasicAuthentication";
+	public static final String REST_CLIENT_EXCEPTION = "org.springframework.web.client.RestClientException";
 
 	/*
 	 * RoboGuice