Merge pull request #117 from algolia/offline

Integrate the latest offline features

Author: PLNech

ChangeLog.md

@@ -1,6 +1,21 @@
 Change Log
 ==========
 
+## Next version
+
+- New `Index.multipleQueriesAsync()` method (convenience shortcut to `Client.multipleQueriesAsync()`)
+
+The following changes impact the offline mode only:
+
+- Require an Android `Context` to be provided during client construction. **Warning: breaking change.**
+- Offline requests now also work for disjunctive faceting
+- New offline fallback strategy. **Warning: breaking change:** preemptive search no longer supported.
+- Improve detection of non-existent indices
+- Improve error handling
+- Fix crash on concurrent accesses to a local index
+- Fix potential race condition in lazy instantiation of the local index
+
+
 ## 3.2.2 (2016-06-06)
 
 - Better resource handling: close client streams and connection when appropriate

algoliasearch/build-offline.gradle

@@ -37,7 +37,7 @@ android {
 }
 
 dependencies {
-    offlineCompile "com.algolia:algoliasearch-offline-core-android:0.1"
+    offlineCompile "com.algolia:algoliasearch-offline-core-android:0.2"
 }
 
 

algoliasearch/src/main/java/com/algolia/search/saas/Client.java

@@ -790,6 +790,9 @@ abstract class AsyncTaskRequest implements Request {
         /** The completion handler notified of the result. May be null if the caller omitted it. */
         private CompletionHandler completionHandler;
 
+        /** The executor used to execute the request. */
+        private ExecutorService executorService;
+
         private boolean finished = false;
 
         /**
@@ -820,12 +823,23 @@ protected void onCancelled(APIResult apiResult) {
         };
 
         /**
-         * Construct a new request with the specified completion handler.
+         * Construct a new request with the specified completion handler, executing on the client's default executor.
          *
          * @param completionHandler The completion handler to be notified of results. May be null if the caller omitted it.
          */
         AsyncTaskRequest(CompletionHandler completionHandler) {
+            this(completionHandler, searchExecutorService);
+        }
+
+        /**
+         * Construct a new request with the specified completion handler, executing on the specified executor.
+         *
+         * @param completionHandler The completion handler to be notified of results. May be null if the caller omitted it.
+         * @param executorService Executor service on which to execute the request.
+         */
+        AsyncTaskRequest(CompletionHandler completionHandler, @NonNull ExecutorService executorService) {
             this.completionHandler = completionHandler;
+            this.executorService = executorService;
         }
 
         /**
@@ -850,7 +864,7 @@ AsyncTaskRequest start() {
             // WARNING: Starting with Honeycomb (3.0), `AsyncTask` execution is serial, so we must force parallel
             // execution. See <http://developer.android.com/reference/android/os/AsyncTask.html>.
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
-                task.executeOnExecutor(searchExecutorService);
+                task.executeOnExecutor(executorService);
             } else {
                 task.execute();
             }

algoliasearch/src/main/java/com/algolia/search/saas/Index.java

@@ -135,6 +135,30 @@ public JSONObject searchSync(@NonNull Query query) throws AlgoliaException {
         return search(query);
     }
 
+    /**
+     * Run multiple queries on this index with one API call.
+     * A variant of {@link Client#multipleQueriesAsync(List, Client.MultipleQueriesStrategy, CompletionHandler)}
+     * where the targeted index is always the receiver.
+     *
+     * @param queries The queries to run.
+     * @param strategy The strategy to use.
+     * @param completionHandler The listener that will be notified of the request's outcome.
+     * @return A cancellable request.
+     */
+    public Request multipleQueriesAsync(final @NonNull List<Query> queries, final Client.MultipleQueriesStrategy strategy, @NonNull CompletionHandler completionHandler) {
+        final List<Query> queriesCopy = new ArrayList<>(queries.size());
+        for (Query query: queries) {
+            queriesCopy.add(new Query(query));
+        }
+        return getClient().new AsyncTaskRequest(completionHandler) {
+            @NonNull
+            @Override
+            JSONObject run() throws AlgoliaException {
+                return multipleQueries(queriesCopy, strategy == null ? null : strategy.toString());
+            }
+        }.start();
+    }
+
     /**
      * Search inside this index synchronously.
      *
@@ -153,20 +177,22 @@ protected byte[] searchSyncRaw(@NonNull Query query) throws AlgoliaException {
      * @param completionHandler The listener that will be notified of the request's outcome.
      * @return A cancellable request.
      */
-    public Request searchDisjunctiveFacetingAsync(@NonNull Query query, @NonNull List<String> disjunctiveFacets, @NonNull Map<String, List<String>> refinements, @NonNull CompletionHandler completionHandler) {
-        final Query queryCopy = new Query(query);
-        final List<String> disjunctiveFacetsCopy = new ArrayList<>(disjunctiveFacets);
-        final Map<String, List<String>> refinementsCopy = new HashMap<>();
-        for (Map.Entry<String, List<String>> entry : refinements.entrySet()) {
-            refinementsCopy.put(entry.getKey(), new ArrayList<String>(entry.getValue()));
-        }
-        return getClient().new AsyncTaskRequest(completionHandler) {
-            @NonNull
+    public Request searchDisjunctiveFacetingAsync(@NonNull Query query, @NonNull final List<String> disjunctiveFacets, @NonNull final Map<String, List<String>> refinements, @NonNull final CompletionHandler completionHandler) {
+        final List<Query> queries = computeDisjunctiveFacetingQueries(query, disjunctiveFacets, refinements);
+        return multipleQueriesAsync(queries, null, new CompletionHandler() {
             @Override
-            JSONObject run() throws AlgoliaException {
-                return searchDisjunctiveFaceting(queryCopy, disjunctiveFacetsCopy, refinementsCopy);
+            public void requestCompleted(JSONObject content, AlgoliaException error) {
+                JSONObject aggregatedResults = null;
+                try {
+                    if (content != null) {
+                        aggregatedResults = aggregateDisjunctiveFacetingResults(content, disjunctiveFacets, refinements);
+                    }
+                } catch (AlgoliaException e) {
+                    error = e;
+                }
+                completionHandler.requestCompleted(aggregatedResults, error);
             }
-        }.start();
+        });
     }
 
     /**
@@ -957,25 +983,38 @@ protected JSONObject clearIndex() throws AlgoliaException {
     }
 
     /**
-     * Perform a search with disjunctive facets generating as many queries as number of disjunctive facets
+     * Filter disjunctive refinements from generic refinements and a list of disjunctive facets.
      *
-     * @param query             the query
      * @param disjunctiveFacets the array of disjunctive facets
      * @param refinements       Map representing the current refinements
-     * @throws AlgoliaException
+     * @return The disjunctive refinements
      */
-    protected JSONObject searchDisjunctiveFaceting(@NonNull Query query, @NonNull List<String> disjunctiveFacets, @NonNull Map<String, List<String>> refinements) throws AlgoliaException {
-        // Retain only refinements corresponding to the disjunctive facets.
+    private @NonNull Map<String, List<String>> computeDisjunctiveRefinements(@NonNull List<String> disjunctiveFacets, @NonNull Map<String, List<String>> refinements)
+    {
         Map<String, List<String>> disjunctiveRefinements = new HashMap<>();
         for (Map.Entry<String, List<String>> elt : refinements.entrySet()) {
             if (disjunctiveFacets.contains(elt.getKey())) {
                 disjunctiveRefinements.put(elt.getKey(), elt.getValue());
             }
         }
+        return disjunctiveRefinements;
+    }
+
+    /**
+     * Compute the queries to run to implement disjunctive faceting.
+     *
+     * @param query             The query.
+     * @param disjunctiveFacets List of disjunctive facets.
+     * @param refinements       The current refinements, mapping facet names to a list of values.
+     * @return A list of queries suitable for {@link Index#multipleQueries}.
+     */
+    private @NonNull List<Query> computeDisjunctiveFacetingQueries(@NonNull Query query, @NonNull List<String> disjunctiveFacets, @NonNull Map<String, List<String>> refinements) {
+        // Retain only refinements corresponding to the disjunctive facets.
+        Map<String, List<String>> disjunctiveRefinements = computeDisjunctiveRefinements(disjunctiveFacets, refinements);
 
         // build queries
         // TODO: Refactor using JSON array notation: safer and clearer.
-        List<IndexQuery> queries = new ArrayList<>();
+        List<Query> queries = new ArrayList<>();
         // hits + regular facets query
         StringBuilder filters = new StringBuilder();
         boolean first_global = true;
@@ -1010,7 +1049,7 @@ protected JSONObject searchDisjunctiveFaceting(@NonNull Query query, @NonNull Li
             }
         }
 
-        queries.add(new IndexQuery(this.indexName, new Query(query).set("facetFilters", filters.toString())));
+        queries.add(new Query(query).set("facetFilters", filters.toString()));
         // one query per disjunctive facet (use all refinements but the current one + hitsPerPage=1 + single facet
         for (String disjunctiveFacet : disjunctiveFacets) {
             filters = new StringBuilder();
@@ -1049,11 +1088,25 @@ protected JSONObject searchDisjunctiveFaceting(@NonNull Query query, @NonNull Li
                 }
             }
             String[] facets = new String[]{disjunctiveFacet};
-            queries.add(new IndexQuery(this.indexName, new Query(query).setHitsPerPage(0).setAnalytics(false)
+            queries.add(new Query(query).setHitsPerPage(0).setAnalytics(false)
                     .setAttributesToRetrieve().setAttributesToHighlight().setAttributesToSnippet()
-                    .setFacets(facets).set("facetFilters", filters.toString())));
+                    .setFacets(facets).set("facetFilters", filters.toString()));
         }
-        JSONObject answers = this.client.multipleQueries(queries, null);
+        return queries;
+    }
+
+    /**
+     * Aggregate results from multiple queries into disjunctive faceting results.
+     *
+     * @param answers The response from the multiple queries.
+     * @param disjunctiveFacets List of disjunctive facets.
+     * @param refinements Facet refinements.
+     * @return The aggregated results.
+     * @throws AlgoliaException
+     */
+    private JSONObject aggregateDisjunctiveFacetingResults(@NonNull JSONObject answers, @NonNull List<String> disjunctiveFacets, @NonNull Map<String, List<String>> refinements) throws AlgoliaException
+    {
+        Map<String, List<String>> disjunctiveRefinements = computeDisjunctiveRefinements(disjunctiveFacets, refinements);
 
         // aggregate answers
         // first answer stores the hits + regular facets
@@ -1099,4 +1152,21 @@ protected JSONObject browseFrom(@NonNull String cursor) throws AlgoliaException
             throw new Error(e); // Should never happen: UTF-8 is always supported.
         }
     }
+
+    /**
+     * Run multiple queries on this index with one API call.
+     * A variant of {@link Client#multipleQueries(List, String)} where all queries target this index.
+     *
+     * @param queries Queries to run.
+     * @param strategy Strategy to use.
+     * @return The JSON results returned by the server.
+     * @throws AlgoliaException
+     */
+    protected JSONObject multipleQueries(@NonNull List<Query> queries, String strategy) throws AlgoliaException {
+        List<IndexQuery> requests = new ArrayList<>(queries.size());
+        for (Query query: queries) {
+            requests.add(new IndexQuery(this, query));
+        }
+        return client.multipleQueries(requests, strategy);
+    }
 }