add counting ability on client (#218)

* add counting ability on client

* change param name

* add sdkCounterUiEditor usage

* rebase

* change counter logic

* send counts

* updated counting to match iOS design

* renamed LPCountAggregator -> CountAggregator

* remove extra lines, update test inputs

* add newline at end of Log.java

* remove 4 spaces in Log.java

Author: e7mac

AndroidSDKCore/src/main/java/com/leanplum/Leanplum.java

@@ -36,6 +36,7 @@
 import com.leanplum.internal.Constants;
 import com.leanplum.internal.FileManager;
 import com.leanplum.internal.JsonConverter;
+import com.leanplum.internal.CountAggregator;
 import com.leanplum.internal.LeanplumEventDataManager;
 import com.leanplum.internal.LeanplumInternal;
 import com.leanplum.internal.LeanplumMessageMatchFilter;
@@ -55,10 +56,13 @@
 import org.json.JSONObject;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Date;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.TimeZone;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
@@ -814,6 +818,7 @@ protected Void doInBackground(Void... params) {
               Constants.loggingEnabled = true;
             }
 
+            parseSdkCounters(response);
             parseVariantDebugInfo(response);
 
             // Allow bidirectional realtime variable updates.
@@ -2158,4 +2163,13 @@ private static void parseVariantDebugInfo(JSONObject response) {
   public static void clearUserContent() {
     VarCache.clearUserContent();
   }
+
+  private static void parseSdkCounters(JSONObject response) {
+    JSONArray enabledCounters = response.optJSONArray(
+            Constants.Keys.ENABLED_COUNTERS);
+    if (enabledCounters != null) {
+      HashSet counterSet = new HashSet<>(Arrays.asList(enabledCounters));
+      CountAggregator.INSTANCE.setEnabledCounters(counterSet);
+    }
+  }
 }

AndroidSDKCore/src/main/java/com/leanplum/internal/Constants.java

@@ -151,6 +151,7 @@ public static class Params {
     public static final String KINDS = "kinds";
     public static final String LIMIT_TRACKING = "limitTracking";
     public static final String MESSAGE = "message";
+    public static final String COUNT = "count";
     public static final String MESSAGE_ID = "messageId";
     public static final String NEW_USER_ID = "newUserId";
     public static final String INBOX_MESSAGE_ID = "newsfeedMessageId";
@@ -206,6 +207,7 @@ public static class Keys {
     public static final String SUBTITLE = "Subtitle";
     public static final String SYNC_INBOX = "syncNewsfeed";
     public static final String LOGGING_ENABLED = "loggingEnabled";
+    public static final String ENABLED_COUNTERS = "enabledSdkCounters";
     public static final String TIMEZONE = "timezone";
     public static final String TIMEZONE_OFFSET_SECONDS = "timezoneOffsetSeconds";
     public static final String TITLE = "Title";
@@ -250,6 +252,7 @@ public static class Values {
     public static final String DEFAULT_PUSH_MESSAGE = "Push message goes here.";
     public static final String SDK_LOG = "sdkLog";
     public static final String SDK_ERROR = "sdkError";
+    public static final String SDK_COUNT = "sdkCount";
     public static final String FILE_PREFIX = "__file__";
   }
 

AndroidSDKCore/src/main/java/com/leanplum/internal/CountAggregator.java

@@ -0,0 +1,60 @@
+package com.leanplum.internal;
+
+import java.util.HashSet;
+import java.util.HashMap;
+import java.util.Map;
+
+public class CountAggregator {
+    public static final CountAggregator INSTANCE = new CountAggregator();
+
+    private HashSet<String> enabledCounters = new HashSet<>();
+    private final HashMap<String, Integer> counts = new HashMap<>();
+
+    public void setEnabledCounters(HashSet<String> enabledCounters) {
+        this.enabledCounters = enabledCounters;
+    }
+
+    public void incrementCount(String name) {
+        incrementCount(name, 1);
+    }
+
+    public void incrementCount(String name, int incrementCount) {
+        if (enabledCounters.contains(name)) {
+            Integer count = 0;
+            if (counts.containsKey(name)) {
+                count = counts.get(name);
+            }
+            count = count + incrementCount;
+            counts.put(name, count);
+        }
+    }
+
+    private HashMap<String, Integer> getAndClearCounts() {
+        HashMap<String, Integer> previousCounts = new HashMap<>();
+        previousCounts.putAll(counts);
+        counts.clear();
+        return previousCounts;
+    }
+
+    public void sendAllCounts() {
+        HashMap<String, Integer> counts = getAndClearCounts();
+
+        for(Map.Entry<String, Integer> entry : counts.entrySet()) {
+            String name = entry.getKey();
+            Integer count = entry.getValue();
+            try {
+                HashMap<String, Object> params = new HashMap<>();
+                params.put(Constants.Params.TYPE, Constants.Values.SDK_COUNT);
+                params.put(Constants.Params.MESSAGE, name);
+                params.put(Constants.Params.COUNT, count);
+                Request.post(Constants.Methods.LOG, params).sendEventually();
+            } catch (Throwable t) {
+                android.util.Log.e("Leanplum", "Unable to send count.", t);
+            }
+        }
+    }
+
+    public HashMap<String, Integer> getCounts() {
+        return counts;
+    }
+}

AndroidSDKCore/src/main/java/com/leanplum/internal/LeanplumUIEditorWrapper.java

@@ -63,6 +63,7 @@ protected LeanplumUIEditorWrapper() {
           interfaceEditorSingleton = (LeanplumUIEditor) method.invoke(null);
           if (interfaceEditorSingleton != null) {
             interfaceEditorSingleton.allowInterfaceEditing(Constants.isDevelopmentModeEnabled);
+            CountAggregator.INSTANCE.incrementCount("sdkCountUiEditor");
           }
         } catch (IllegalAccessException e) {
           Util.handleException(e);

AndroidSDKCore/src/main/java/com/leanplum/internal/Request.java

@@ -581,6 +581,7 @@ private RequestsWithEncoding getRequestsWithEncodedString() {
   }
 
   private void sendRequests() {
+    CountAggregator.INSTANCE.sendAllCounts();
     requestSequenceRecorder.beforeRead();
 
     RequestsWithEncoding requestsWithEncoding = getRequestsWithEncodedString();

AndroidSDKTests/src/test/java/com/leanplum/internal/CountAggregatorTest.java

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2018, 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.internal;
+
+import com.leanplum.__setup.AbstractTest;
+
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Arrays;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author Grace Gu
+ */
+public class CountAggregatorTest extends AbstractTest {
+  @Test
+  public void testIncrementDisabledCount() {
+    CountAggregator countAggregator = new CountAggregator();
+    String testString = "test";
+
+    countAggregator.incrementCount(testString);
+    HashMap<String, Integer> counts = countAggregator.getCounts();
+    assertEquals(null, counts.get(testString));
+
+    countAggregator.incrementCount(testString);
+    counts = countAggregator.getCounts();
+    assertEquals(null, counts.get(testString));
+  }
+
+  @Test
+  public void testIncrementCount() {
+    CountAggregator countAggregator = new CountAggregator();
+    String testString = "test";
+    HashSet<String> testSet = new HashSet<String>(Arrays.asList(testString));
+    countAggregator.setEnabledCounters(testSet);
+
+    countAggregator.incrementCount(testString);
+    HashMap<String, Integer> counts = countAggregator.getCounts();
+    assertEquals(1, counts.get(testString).intValue());
+
+    countAggregator.incrementCount(testString);
+    counts = countAggregator.getCounts();
+    assertEquals(2, counts.get(testString).intValue());
+  }
+
+  @Test
+  public void testIncrementDisabledCountMultiple() {
+    CountAggregator countAggregator = new CountAggregator();
+    String testString = "test";
+
+    countAggregator.incrementCount(testString, 2);
+    HashMap<String, Integer> counts = countAggregator.getCounts();
+    assertEquals(null, counts.get(testString));
+
+    countAggregator.incrementCount(testString, 15);
+    counts = countAggregator.getCounts();
+    assertEquals(null, counts.get(testString));
+  }
+
+  @Test
+  public void testIncrementCountMultiple() {
+    CountAggregator countAggregator = new CountAggregator();
+    String testString = "test";
+    HashSet<String> testSet = new HashSet<String>(Arrays.asList(testString));
+    countAggregator.setEnabledCounters(testSet);
+
+    countAggregator.incrementCount(testString, 2);
+    HashMap<String, Integer> counts = countAggregator.getCounts();
+    assertEquals(2, counts.get(testString).intValue());
+
+    countAggregator.incrementCount(testString, 15);
+    counts = countAggregator.getCounts();
+    assertEquals(17, counts.get(testString).intValue());
+  }
+}