Merge branch 'master' of github.com:apollographql/apollo-android into…

… feature-espresso-idling-resource

apollo-runtime/src/main/java/com/apollographql/apollo/ApolloClient.java

@@ -188,6 +188,7 @@ private <D extends Operation.Data, T, V extends Operation.Variables> RealApolloC
         .logger(logger)
         .applicationInterceptors(applicationInterceptors)
         .tracker(callTracker)
+        .refetchQueries(Collections.<Query>emptyList())
         .refetchQueryNames(Collections.<OperationName>emptyList())
         .build();
   }

apollo-runtime/src/main/java/com/apollographql/apollo/internal/RealApolloCall.java

@@ -75,22 +75,39 @@ public static <T> Builder<T> builder() {
   }
 
   private RealApolloCall(Builder<T> builder) {
-    this.operation = builder.operation;
-    this.serverUrl = builder.serverUrl;
-    this.httpCallFactory = builder.httpCallFactory;
-    this.httpCache = builder.httpCache;
-    this.httpCachePolicy = builder.httpCachePolicy;
-    this.moshi = builder.moshi;
-    this.responseFieldMapper = builder.responseFieldMapper;
-    this.customTypeAdapters = builder.customTypeAdapters;
-    this.apolloStore = builder.apolloStore;
-    this.cacheControl = builder.cacheControl;
-    this.cacheHeaders = builder.cacheHeaders;
-    this.dispatcher = builder.dispatcher;
-    this.logger = builder.logger;
-    this.applicationInterceptors = builder.applicationInterceptors;
-    this.refetchQueryNames = builder.refetchQueryNames;
-    this.tracker = builder.tracker;
+    operation = builder.operation;
+    serverUrl = builder.serverUrl;
+    httpCallFactory = builder.httpCallFactory;
+    httpCache = builder.httpCache;
+    httpCachePolicy = builder.httpCachePolicy;
+    moshi = builder.moshi;
+    responseFieldMapperFactory = builder.responseFieldMapperFactory;
+    customTypeAdapters = builder.customTypeAdapters;
+    apolloStore = builder.apolloStore;
+    cacheControl = builder.cacheControl;
+    cacheHeaders = builder.cacheHeaders;
+    dispatcher = builder.dispatcher;
+    logger = builder.logger;
+    applicationInterceptors = builder.applicationInterceptors;
+    refetchQueryNames = builder.refetchQueryNames;
+    refetchQueries = builder.refetchQueries;
+    tracker = builder.tracker;
+    if (refetchQueries.isEmpty() || builder.apolloStore == null) {
+      queryFetcher = Optional.absent();
+    } else {
+      queryFetcher = Optional.of(QueryFetcher.builder()
+          .queries(builder.refetchQueries)
+          .serverUrl(builder.serverUrl)
+          .httpCallFactory(builder.httpCallFactory)
+          .moshi(builder.moshi)
+          .responseFieldMapperFactory(builder.responseFieldMapperFactory)
+          .customTypeAdapters(builder.customTypeAdapters)
+          .apolloStore(builder.apolloStore)
+          .dispatcher(builder.dispatcher)
+          .logger(builder.logger)
+          .applicationInterceptors(builder.applicationInterceptors)
+          .build());
+    }
     interceptorChain = prepareInterceptorChain(operation);
   }
 
@@ -185,73 +202,90 @@ private RealApolloCall(Builder<T> builder) {
         .build();
   }
 
-  final class AsyncCall implements ApolloInterceptor.CallBack {
-
-    private final Callback<T> responseCallback;
+  @Nonnull @Override public ApolloMutationCall<T> refetchQueries(@Nonnull Query... queries) {
+    if (executed.get()) throw new IllegalStateException("Already Executed");
+    return toBuilder()
+        .refetchQueries(Arrays.asList(checkNotNull(queries, "queries == null")))
+        .build();
+  }
 
-    private AsyncCall(Callback<T> callback) {
-      this.responseCallback = callback;
-    }
+    final class AsyncCall implements ApolloInterceptor.CallBack {
 
-    @Override public void onResponse(@Nonnull ApolloInterceptor.InterceptorResponse response) {
-      try {
+      private final Callback<T> responseCallback;
 
-        if (responseCallback == null) {
-          return;
-        }
-        if (canceled) {
-          responseCallback.onCanceledError(new ApolloCanceledException("Canceled"));
-        } else { //noinspection unchecked
-          responseCallback.onResponse(response.parsedResponse.get());
-        }
-      } finally {
-        tracker.onAsyncCallFinished(this);
+      private AsyncCall(Callback<T> callback) {
+        this.responseCallback = callback;
       }
-    }
 
-    @Override public void onFailure(@Nonnull ApolloException e) {
-      try {
-
-        if (responseCallback == null) {
-          return;
+      @Override public void onResponse(@Nonnull final ApolloInterceptor.InterceptorResponse response) {
+        try {
+
+          if (responseCallback == null) {
+            return;
+          }
+          if (canceled) {
+            responseCallback.onCanceledError(new ApolloCanceledException("Canceled"));
+            return;
+          }
+          if(queryFetcher.isPresent()){
+            queryFetcher.get().refetchAsync(new QueryFetcher.OnFetchCompleteCallback() {
+              @Override public void onFetchComplete() {
+                //noinspection unchecked
+                responseCallback.onResponse(response.parsedResponse.get());
+              }
+            });
+          }
+          else { //noinspection unchecked
+            responseCallback.onResponse(response.parsedResponse.get());
+          }
+        } finally {
+          tracker.onAsyncCallFinished(this);
         }
+      }
 
-        if (canceled) {
-          responseCallback.onCanceledError(new ApolloCanceledException("Canceled", e));
-        } else if (e instanceof ApolloHttpException) {
-          responseCallback.onHttpError((ApolloHttpException) e);
-        } else if (e instanceof ApolloParseException) {
-          responseCallback.onParseError((ApolloParseException) e);
-        } else if (e instanceof ApolloNetworkException) {
-          responseCallback.onNetworkError((ApolloNetworkException) e);
-        } else {
-          responseCallback.onFailure(e);
+      @Override public void onFailure(@Nonnull ApolloException e) {
+        try {
+
+          if (responseCallback == null) {
+            return;
+          }
+
+          if (canceled) {
+            responseCallback.onCanceledError(new ApolloCanceledException("Canceled", e));
+          } else if (e instanceof ApolloHttpException) {
+            responseCallback.onHttpError((ApolloHttpException) e);
+          } else if (e instanceof ApolloParseException) {
+            responseCallback.onParseError((ApolloParseException) e);
+          } else if (e instanceof ApolloNetworkException) {
+            responseCallback.onNetworkError((ApolloNetworkException) e);
+          } else {
+            responseCallback.onFailure(e);
+          }
+        } finally {
+          tracker.onAsyncCallFinished(this);
         }
-      } finally {
-        tracker.onAsyncCallFinished(this);
       }
     }
-  }
 
-  public Builder<T> toBuilder() {
-    return RealApolloCall.<T>builder()
-        .operation(operation)
-        .serverUrl(serverUrl)
-        .httpCallFactory(httpCallFactory)
-        .httpCache(httpCache)
-        .httpCachePolicy(httpCachePolicy)
-        .moshi(moshi)
-        .responseFieldMapperFactory(responseFieldMapperFactory)
-        .customTypeAdapters(customTypeAdapters)
-        .apolloStore(apolloStore)
-        .cacheControl(cacheControl)
-        .cacheHeaders(cacheHeaders)
-        .dispatcher(dispatcher)
-        .logger(logger)
-        .applicationInterceptors(applicationInterceptors)
-        .refetchQueryNames(refetchQueryNames)
-        .refetchQueries(refetchQueries);
-  }
+    public Builder<T> toBuilder () {
+      return RealApolloCall.<T>builder()
+          .operation(operation)
+          .serverUrl(serverUrl)
+          .httpCallFactory(httpCallFactory)
+          .httpCache(httpCache)
+          .httpCachePolicy(httpCachePolicy)
+          .moshi(moshi)
+          .responseFieldMapperFactory(responseFieldMapperFactory)
+          .customTypeAdapters(customTypeAdapters)
+          .apolloStore(apolloStore)
+          .cacheControl(cacheControl)
+          .cacheHeaders(cacheHeaders)
+          .dispatcher(dispatcher)
+          .logger(logger)
+          .applicationInterceptors(applicationInterceptors)
+          .refetchQueryNames(refetchQueryNames)
+          .refetchQueries(refetchQueries);
+    }
 
   private ApolloInterceptorChain prepareInterceptorChain(Operation operation) {
     List<ApolloInterceptor> interceptors = new ArrayList<>();
@@ -286,6 +320,7 @@ public static final class Builder<T> {
     List<ApolloInterceptor> applicationInterceptors;
     List<OperationName> refetchQueryNames;
     ApolloCallTracker tracker;
+    List<Query> refetchQueries = emptyList();
 
     public Builder<T> operation(Operation operation) {
       this.operation = operation;