feat(inbox): Callback for when Inbox was synced via forceContentUpdat… (#111)

* feat(inbox): Callback for when Inbox was synced via forceContentUpdate(LP-6295).

Author: Enuviel

AndroidSDK/src/com/leanplum/Leanplum.java

@@ -1921,6 +1921,8 @@ public void response(JSONObject response) {
               applyContentInResponse(response, false);
               if (response.optBoolean(Constants.Keys.SYNC_INBOX, false)) {
                 LeanplumInbox.getInstance().downloadMessages();
+              } else {
+                LeanplumInbox.getInstance().triggerInboxSyncedWithStatus(true);
               }
               if (response.optBoolean(Constants.Keys.LOGGING_ENABLED, false)) {
                 Constants.loggingEnabled = true;
@@ -1940,6 +1942,7 @@ public void error(Exception e) {
           if (callback != null) {
             OsHandler.getInstance().post(callback);
           }
+          LeanplumInbox.getInstance().triggerInboxSyncedWithStatus(false);
         }
       });
       req.sendIfConnected();

AndroidSDK/src/com/leanplum/LeanplumInbox.java

@@ -25,6 +25,7 @@
 import android.content.SharedPreferences;
 
 import com.leanplum.callbacks.InboxChangedCallback;
+import com.leanplum.callbacks.InboxSyncedCallback;
 import com.leanplum.callbacks.VariablesChangedCallback;
 import com.leanplum.internal.AESCrypt;
 import com.leanplum.internal.CollectionUtil;
@@ -65,13 +66,15 @@ public class LeanplumInbox {
   private boolean didLoad = false;
 
   private final List<InboxChangedCallback> changedCallbacks;
+  private final List<InboxSyncedCallback> syncedCallbacks;
   private final Object updatingLock = new Object();
 
   private LeanplumInbox() {
     this.unreadCount = 0;
     this.messages = new HashMap<>();
     this.didLoad = false;
     this.changedCallbacks = new ArrayList<>();
+    this.syncedCallbacks = new ArrayList<>();
     downloadedImageUrls = new HashSet<>();
   }
 
@@ -178,6 +181,29 @@ public void removeChangedHandler(InboxChangedCallback handler) {
     }
   }
 
+  /**
+   * Add a callback for when the forceContentUpdate was called.
+   *
+   * @param handler InboxSyncedCallback callback that need to be added.
+   */
+  public void addSyncedHandler(InboxSyncedCallback handler) {
+    synchronized (syncedCallbacks) {
+      syncedCallbacks.add(handler);
+    }
+  }
+
+
+  /**
+   * Removes a inbox synced callback.
+   *
+   * @param handler InboxSyncedCallback callback that need to be removed.
+   */
+  public void removeSyncedHandler(InboxSyncedCallback handler) {
+    synchronized (syncedCallbacks) {
+      syncedCallbacks.remove(handler);
+    }
+  }
+
   /**
    * Static 'getInstance' method.
    */
@@ -241,6 +267,19 @@ void triggerChanged() {
     }
   }
 
+  /**
+   * Trigger InboxSyncedCallback with status of forceContentUpdate.
+   * @param success True if forceContentUpdate was successful.
+   */
+  void triggerInboxSyncedWithStatus(boolean success) {
+    synchronized (changedCallbacks) {
+      for (InboxSyncedCallback callback : syncedCallbacks) {
+        callback.setSuccess(success);
+        OsHandler.getInstance().post(callback);
+      }
+    }
+  }
+
   void load() {
     if (Constants.isNoop()) {
       return;
@@ -353,6 +392,7 @@ public void response(JSONObject response) {
 
           if (!willDownladImages) {
             update(messages, unreadCount, true);
+            triggerInboxSyncedWithStatus(true);
             return;
           }
 
@@ -362,13 +402,21 @@ public void response(JSONObject response) {
                 @Override
                 public void variablesChanged() {
                   update(messages, totalUnreadCount, true);
+                  triggerInboxSyncedWithStatus(true);
                 }
               });
         } catch (Throwable t) {
+          triggerInboxSyncedWithStatus(false);
           Util.handleException(t);
         }
       }
     });
+    req.onError(new Request.ErrorCallback() {
+      @Override
+      public void error(Exception e) {
+        triggerInboxSyncedWithStatus(false);
+      }
+    });
     req.sendIfConnected();
   }
 

AndroidSDK/src/com/leanplum/callbacks/InboxSyncedCallback.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2017, Leanplum, Inc. All rights reserved.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 com.leanplum.callbacks;
+
+/**
+ * Callback that gets run when forceContentUpdate was called.
+ *
+ * @author Anna Orlova
+ */
+public abstract class InboxSyncedCallback implements Runnable {
+  private boolean success;
+
+  public void setSuccess(boolean success) {
+    this.success = success;
+  }
+
+  public void run() {
+    this.onForceContentUpdate(success);
+  }
+
+  /**
+   * Call when forceContentUpdate was called.
+   * @param success True if syncing was successful.
+   */
+  public abstract void onForceContentUpdate(boolean success);
+}

AndroidSDKTests/src/test/java/com/leanplum/LeanplumInboxTest.java

@@ -24,7 +24,9 @@
 import com.leanplum._whitebox.utilities.RequestHelper;
 import com.leanplum._whitebox.utilities.ResponseHelper;
 import com.leanplum.callbacks.InboxChangedCallback;
+import com.leanplum.callbacks.InboxSyncedCallback;
 import com.leanplum.internal.Constants;
+import com.leanplum.internal.Util;
 
 import org.junit.Test;
 
@@ -38,6 +40,7 @@
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
+import static org.powermock.api.mockito.PowerMockito.doReturn;
 
 /**
  * Tests the inbox.
@@ -59,9 +62,24 @@ public void onRequest(String httpMethod, String apiMethod, Map<String, Object> p
                 assertEquals(Constants.Methods.GET_INBOX_MESSAGES, apiMethod);
             }
         });
+
+        // Validate inbox synced callback when messages changes.
+        InboxSyncedCallback inboxSyncedCallback=new InboxSyncedCallback() {
+            @Override
+            public void onForceContentUpdate(boolean success) {
+                assertTrue(success);
+            }
+        };
+
+        // Add synced callback to be able to validate.
+        Leanplum.getInbox().addSyncedHandler(inboxSyncedCallback);
+
         // Download messages.
         Leanplum.getInbox().downloadMessages();
 
+        //  Remove synced callback afterwards so we don't get synced callbacks anymore.
+        Leanplum.getInbox().removeSyncedHandler(inboxSyncedCallback);
+
         // Validate inbox callback when messages changes.
         InboxChangedCallback callback = new InboxChangedCallback() {
             @Override
@@ -116,6 +134,26 @@ public void inboxChanged() {
 
         Leanplum.getInbox().removeMessage(messageById.getMessageId());
         assertEquals(1, Leanplum.getInbox().allMessages().size());
+
+        // Validate inbox synced callback with false when there is no internet .
+        InboxSyncedCallback inboxSyncedCallbackFalse=new InboxSyncedCallback() {
+            @Override
+            public void onForceContentUpdate(boolean success) {
+                assertFalse(success);
+            }
+        };
+
+        // Add synced callback  to be able to validate.
+        Leanplum.getInbox().addSyncedHandler(inboxSyncedCallbackFalse);
+
+        // Return false when checks for internet connection.
+        doReturn(false).when(Util.class, "isConnected");
+
+        // Download messages.
+        Leanplum.getInbox().downloadMessages();
+
+        //  Remove synced callback afterwards so we don't get synced callbacks anymore.
+        Leanplum.getInbox().removeSyncedHandler(inboxSyncedCallbackFalse);
     }
 
     @Test