[offline] Add support for getObjects in MirroredIndex

- Same offline fallback policy as search.
- Purely online and purely offline variants.

NOTE: Had to rewire the online overloads to target the same implementation, so that it can be easily overloaded on the offline side.

Author: Clément Le Provost

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

@@ -399,12 +399,7 @@ public Request partialUpdateObjectsAsync(final @NonNull JSONArray partialObjects
      * @return A cancellable request.
      */
     public Request getObjectAsync(final @NonNull String objectID, @NonNull CompletionHandler completionHandler) {
-        return getClient().new AsyncTaskRequest(completionHandler) {
-            @NonNull
-            @Override protected JSONObject run() throws AlgoliaException {
-                return getObject(objectID);
-            }
-        }.start();
+        return getObjectAsync(objectID, null, completionHandler);
     }
 
     /**
@@ -432,12 +427,7 @@ public Request getObjectAsync(final @NonNull String objectID, final List<String>
      * @return A cancellable request.
      */
     public Request getObjectsAsync(final @NonNull List<String> objectIDs, @NonNull CompletionHandler completionHandler) {
-        return getClient().new AsyncTaskRequest(completionHandler) {
-            @NonNull
-            @Override protected JSONObject run() throws AlgoliaException {
-                return getObjects(objectIDs);
-            }
-        }.start();
+        return getObjectsAsync(objectIDs, null, completionHandler);
     }
 
     /**

algoliasearch/src/offline/java/com/algolia/search/saas/MirroredIndex.java

@@ -1245,6 +1245,149 @@ private JSONObject _browseMirror(@NonNull Query query) throws AlgoliaException
         }
     }
 
+    // ----------------------------------------------------------------------
+    // Getting individual objects
+    // ----------------------------------------------------------------------
+
+    /**
+     * Get individual objects from the online API, falling back to the local mirror in case of error (when enabled).
+     *
+     * @param objectIDs Identifiers of objects to retrieve.
+     * @param attributesToRetrieve Attributes to retrieve. If `null` or if at least one item is `*`, all retrievable
+     *                             attributes will be retrieved.
+     * @param completionHandler The listener that will be notified of the request's outcome.
+     * @return A cancellable request.
+     */
+    @Override
+    public Request getObjectsAsync(final @NonNull List<String> objectIDs, final @Nullable List<String> attributesToRetrieve, @NonNull CompletionHandler completionHandler) {
+        if (!mirrored) {
+            return super.getObjectsAsync(objectIDs, attributesToRetrieve, completionHandler);
+        } else {
+            return new OnlineOfflineGetObjectsRequest(objectIDs, attributesToRetrieve, completionHandler).start();
+        }
+    }
+
+    private class OnlineOfflineGetObjectsRequest extends OnlineOfflineRequest {
+        private final List<String> objectIDs;
+        private final List<String> attributesToRetrieve;
+
+        public OnlineOfflineGetObjectsRequest(@NonNull List<String> objectIDs, final @Nullable List<String> attributesToRetrieve, @NonNull CompletionHandler completionHandler) {
+            super(completionHandler);
+            this.objectIDs = objectIDs;
+            this.attributesToRetrieve = attributesToRetrieve;
+        }
+
+        @Override
+        protected Request startOnlineRequest(CompletionHandler completionHandler) {
+            return getObjectsOnlineAsync(objectIDs, attributesToRetrieve, completionHandler);
+        }
+
+        @Override
+        protected Request startOfflineRequest(CompletionHandler completionHandler) {
+            return getObjectsOfflineAsync(objectIDs, attributesToRetrieve, completionHandler);
+        }
+    }
+
+    /**
+     * Get individual objects, explicitly targeting the online API, not the offline mirror.
+     *
+     * @param objectIDs Identifiers of objects to retrieve.
+     * @param attributesToRetrieve Attributes to retrieve. If `null` or if at least one item is `*`, all retrievable
+     *                             attributes will be retrieved.
+     * @param completionHandler The listener that will be notified of the request's outcome.
+     * @return A cancellable request.
+     */
+    public Request getObjectsOnlineAsync(@NonNull final List<String> objectIDs, final @Nullable List<String> attributesToRetrieve, @NonNull final CompletionHandler completionHandler) {
+        return getClient().new AsyncTaskRequest(completionHandler) {
+            @NonNull
+            @Override
+            protected JSONObject run() throws AlgoliaException {
+                return getObjectsOnline(objectIDs, attributesToRetrieve);
+            }
+        }.start();
+    }
+
+    /**
+     * Get individual objects, explicitly targeting the online API, not the offline mirror.
+     *
+     * @param objectIDs Identifiers of objects to retrieve.
+     * @param completionHandler The listener that will be notified of the request's outcome.
+     * @return A cancellable request.
+     */
+    public Request getObjectsOnlineAsync(@NonNull final List<String> objectIDs, @NonNull final CompletionHandler completionHandler) {
+        return getObjectsOnlineAsync(objectIDs, null, completionHandler);
+    }
+
+    private JSONObject getObjectsOnline(@NonNull final List<String> objectIDs, final @Nullable List<String> attributesToRetrieve) throws AlgoliaException {
+        try {
+            JSONObject content = super.getObjects(objectIDs, attributesToRetrieve);
+            // TODO: Factorize origin tagging
+            content.put(JSON_KEY_ORIGIN, JSON_VALUE_ORIGIN_REMOTE);
+            return content;
+        }
+        catch (JSONException e) {
+            throw new AlgoliaException("Failed to patch JSON result");
+        }
+    }
+
+    /**
+     * Get individual objects, explicitly targeting the offline mirror, not the online API.
+     *
+     * @param objectIDs Identifiers of objects to retrieve.
+     * @param attributesToRetrieve Attributes to retrieve. If `null` or if at least one item is `*`, all retrievable
+     *                             attributes will be retrieved.
+     * @param completionHandler The listener that will be notified of the request's outcome.
+     * @return A cancellable request.
+     * @throws IllegalStateException if mirroring is not activated on this index.
+     */
+    public Request getObjectsOfflineAsync(@NonNull final List<String> objectIDs, final @Nullable List<String> attributesToRetrieve, @NonNull CompletionHandler completionHandler) {
+        if (!mirrored) {
+            throw new IllegalStateException("Mirroring not activated on this index");
+        }
+        return getClient().new AsyncTaskRequest(completionHandler, getClient().localSearchExecutorService) {
+            @NonNull
+            @Override
+            protected JSONObject run() throws AlgoliaException {
+                return _getObjectsOffline(objectIDs, attributesToRetrieve);
+            }
+        }.start();
+    }
+
+    /**
+     * Get individual objects, explicitly targeting the offline mirror, not the online API.
+     *
+     * @param objectIDs Identifiers of objects to retrieve.
+     * @param completionHandler The listener that will be notified of the request's outcome.
+     * @return A cancellable request.
+     * @throws IllegalStateException if mirroring is not activated on this index.
+     */
+    public Request getObjectsOfflineAsync(@NonNull final List<String> objectIDs, @NonNull final CompletionHandler completionHandler) {
+        return getObjectsOfflineAsync(objectIDs, null, completionHandler);
+    }
+
+    private JSONObject _getObjectsOffline(@NonNull final List<String> objectIDs, final @Nullable List<String> attributesToRetrieve) throws AlgoliaException
+    {
+        try {
+            Query query = new Query();
+            if (attributesToRetrieve != null) {
+                query.setAttributesToRetrieve(attributesToRetrieve.toArray(new String[attributesToRetrieve.size()]));
+            }
+            Response searchResults = getLocalIndex().getObjects(objectIDs.toArray(new String[objectIDs.size()]), query.build());
+            if (searchResults.getStatusCode() == 200) {
+                String jsonString = new String(searchResults.getData(), "UTF-8");
+                JSONObject json = new JSONObject(jsonString);
+                json.put(JSON_KEY_ORIGIN, JSON_VALUE_ORIGIN_LOCAL);
+                return json;
+            }
+            else {
+                throw new AlgoliaException(searchResults.getErrorMessage(), searchResults.getStatusCode());
+            }
+        }
+        catch (JSONException | UnsupportedEncodingException e) {
+            throw new AlgoliaException("Get objects failed", e);
+        }
+    }
+
     // ----------------------------------------------------------------------
     // Listeners
     // ----------------------------------------------------------------------

algoliasearch/src/test/java/com/algolia/search/saas/IndexTest.java

@@ -429,6 +429,24 @@ public void getObjectsAsync() throws Exception {
         });
     }
 
+    @Test
+    public void getObjectsWithAttributesToRetrieveAsync() throws Exception {
+        List<String> attributesToRetrieve = new ArrayList<>();
+        attributesToRetrieve.add("objectID");
+        index.getObjectsAsync(ids, attributesToRetrieve, new AssertCompletionHandler() {
+            @Override public void doRequestCompleted(JSONObject content, AlgoliaException error) {
+                if (error == null) {
+                    JSONArray res = content.optJSONArray("results");
+                    assertNotNull(res);
+                    assertTrue("Object has unexpected objectId", res.optJSONObject(0).optString("objectID").equals(ids.get(0)));
+                    assertFalse("Object has unexpected 'city' attribute", res.optJSONObject(1).has("city"));
+                } else {
+                    fail(error.getMessage());
+                }
+            }
+        });
+    }
+
     @Test
     public void waitTaskAsync() throws Exception {
         index.addObjectAsync(new JSONObject("{\"city\": \"New York\"}"), new AssertCompletionHandler() {

algoliasearch/src/testOffline/java/com/algolia/search/saas/MirroredIndexTest.java

@@ -32,6 +32,7 @@
 import org.json.JSONObject;
 import org.junit.Test;
 
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.CountDownLatch;
@@ -40,6 +41,7 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.fail;
 
@@ -311,4 +313,58 @@ public void doRequestCompleted(JSONObject content, AlgoliaException error) {
             }
         });
     }
+
+    @Test
+    public void testGetObjects() {
+        final CountDownLatch signal = new CountDownLatch(4);
+
+        // Populate the online index & sync the offline mirror.
+        final MirroredIndex index = client.getIndex(Helpers.safeIndexName(Helpers.getMethodName()));
+        sync(index, new SyncCompletionHandler() {
+            @Override
+            public void syncCompleted(@Nullable Throwable error) {
+                assertNull(error);
+
+                // Query the online index explicitly.
+                index.getObjectsOnlineAsync(Arrays.asList("1"), new AssertCompletionHandler() {
+                    @Override
+                    public void doRequestCompleted(JSONObject content, AlgoliaException error) {
+                        assertNull(error);
+                        assertNotNull(content.optJSONArray("results"));
+                        assertEquals(1, content.optJSONArray("results").length());
+                        assertEquals("remote", content.optString("origin"));
+
+                        // Test offline fallback.
+                        client.setReadHosts("unknown.algolia.com");
+                        index.setRequestStrategy(MirroredIndex.Strategy.FALLBACK_ON_FAILURE);
+                        index.getObjectsAsync(Arrays.asList("1", "2", "3"), new AssertCompletionHandler() {
+                            @Override
+                            public void doRequestCompleted(JSONObject content, AlgoliaException error) {
+                                assertNull(error);
+                                assertNotNull(content.optJSONArray("results"));
+                                assertEquals(3, content.optJSONArray("results").length());
+                                assertEquals("local", content.optString("origin"));
+                                signal.countDown();
+                            }
+                        });
+                        signal.countDown();
+                    }
+                });
+
+                // Query the offline index explicitly.
+                index.getObjectsOfflineAsync(Arrays.asList("1", "2"), new AssertCompletionHandler() {
+                    @Override
+                    public void doRequestCompleted(JSONObject content, AlgoliaException error) {
+                        assertNull(error);
+                        assertNotNull(content.optJSONArray("results"));
+                        assertEquals(2, content.optJSONArray("results").length());
+                        assertEquals("local", content.optString("origin"));
+                        signal.countDown();
+                    }
+                });
+
+                signal.countDown();
+            }
+        });
+    }
 }