List Filters + User Property Cache Limit

sdk/src/androidTest/java/ly/count/android/sdk/ConnectionProcessorTests.java

@@ -30,7 +30,10 @@ of this software and associated documentation files (the "Software"), to deal
 import java.net.URL;
 import java.net.URLConnection;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -130,6 +133,26 @@ public void setUp() {
             @Override public int getRequestTimeoutDurationMillis() {
                 return 30_000;
             }
+
+            @Override public int getUserPropertyCacheLimit() {
+                return 100;
+            }
+
+            @Override public FilterList<Set<String>> getEventFilterList() {
+                return new FilterList<>(new HashSet<>(), false);
+            }
+
+            @Override public FilterList<Set<String>> getUserPropertyFilterList() {
+                return new FilterList<>(new HashSet<>(), false);
+            }
+
+            @Override public FilterList<Set<String>> getSegmentationFilterList() {
+                return new FilterList<>(new HashSet<>(), false);
+            }
+
+            @Override public FilterList<Map<String, Set<String>>> getEventSegmentationFilterList() {
+                return new FilterList<>(new ConcurrentHashMap<>(), false);
+            }
         };
 
         Countly.sharedInstance().setLoggingEnabled(true);

sdk/src/androidTest/java/ly/count/android/sdk/ModuleConfigurationTests.java

@@ -4,6 +4,7 @@
 import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
@@ -644,7 +645,7 @@ public void invalidConfigResponses_AreRejected() {
      */
     @Test
     public void configurationParameterCount() {
-        int configParameterCount = 31; // plus config, timestamp and version parameters
+        int configParameterCount = 40; // plus config, timestamp and version parameters, UPDATE: list filters, and user property cache limit
         int count = 0;
         for (Field field : ModuleConfiguration.class.getDeclaredFields()) {
             if (field.getName().startsWith("keyR")) {
@@ -1123,7 +1124,14 @@ private void initServerConfigWithValues(BiConsumer<CountlyConfig, String> config
             .segmentationValuesLimit(25)
             .breadcrumbLimit(90)
             .traceLengthLimit(78)
-            .traceLinesLimit(89);
+            .traceLinesLimit(89)
+            .userPropertyCacheLimit(67)
+
+            // Filters
+            .eventFilterList(new HashSet<>(), false)
+            .userPropertyFilterList(new HashSet<>(), false)
+            .segmentationFilterList(new HashSet<>(), false)
+            .eventSegmentationFilterMap(new ConcurrentHashMap<>(), false);
 
         String serverConfig = builder.build();
         CountlyConfig countlyConfig = TestUtils.createBaseConfig().setLoggingEnabled(false);

sdk/src/androidTest/java/ly/count/android/sdk/ServerConfigBuilder.java

@@ -1,7 +1,11 @@
 package ly.count.android.sdk;
 
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import org.json.JSONException;
 import org.json.JSONObject;
 import org.junit.Assert;
@@ -13,7 +17,11 @@
 import static ly.count.android.sdk.ModuleConfiguration.keyRCustomEventTracking;
 import static ly.count.android.sdk.ModuleConfiguration.keyRDropOldRequestTime;
 import static ly.count.android.sdk.ModuleConfiguration.keyREnterContentZone;
+import static ly.count.android.sdk.ModuleConfiguration.keyREventBlacklist;
 import static ly.count.android.sdk.ModuleConfiguration.keyREventQueueSize;
+import static ly.count.android.sdk.ModuleConfiguration.keyREventSegmentationBlacklist;
+import static ly.count.android.sdk.ModuleConfiguration.keyREventSegmentationWhitelist;
+import static ly.count.android.sdk.ModuleConfiguration.keyREventWhitelist;
 import static ly.count.android.sdk.ModuleConfiguration.keyRLimitBreadcrumb;
 import static ly.count.android.sdk.ModuleConfiguration.keyRLimitKeyLength;
 import static ly.count.android.sdk.ModuleConfiguration.keyRLimitSegValues;
@@ -25,11 +33,16 @@
 import static ly.count.android.sdk.ModuleConfiguration.keyRNetworking;
 import static ly.count.android.sdk.ModuleConfiguration.keyRRefreshContentZone;
 import static ly.count.android.sdk.ModuleConfiguration.keyRReqQueueSize;
+import static ly.count.android.sdk.ModuleConfiguration.keyRSegmentationBlacklist;
+import static ly.count.android.sdk.ModuleConfiguration.keyRSegmentationWhitelist;
 import static ly.count.android.sdk.ModuleConfiguration.keyRServerConfigUpdateInterval;
 import static ly.count.android.sdk.ModuleConfiguration.keyRSessionTracking;
 import static ly.count.android.sdk.ModuleConfiguration.keyRSessionUpdateInterval;
 import static ly.count.android.sdk.ModuleConfiguration.keyRTimestamp;
 import static ly.count.android.sdk.ModuleConfiguration.keyRTracking;
+import static ly.count.android.sdk.ModuleConfiguration.keyRUserPropertyBlacklist;
+import static ly.count.android.sdk.ModuleConfiguration.keyRUserPropertyCacheLimit;
+import static ly.count.android.sdk.ModuleConfiguration.keyRUserPropertyWhitelist;
 import static ly.count.android.sdk.ModuleConfiguration.keyRVersion;
 import static ly.count.android.sdk.ModuleConfiguration.keyRViewTracking;
 
@@ -169,6 +182,47 @@ ServerConfigBuilder traceLinesLimit(int limit) {
         return this;
     }
 
+    ServerConfigBuilder userPropertyCacheLimit(int limit) {
+        config.put(keyRUserPropertyCacheLimit, limit);
+        return this;
+    }
+
+    ServerConfigBuilder eventFilterList(Set<String> filterList, boolean isWhitelist) {
+        if (isWhitelist) {
+            config.put(keyREventWhitelist, filterList);
+        } else {
+            config.put(keyREventBlacklist, filterList);
+        }
+        return this;
+    }
+
+    ServerConfigBuilder userPropertyFilterList(Set<String> filterList, boolean isWhitelist) {
+        if (isWhitelist) {
+            config.put(keyRUserPropertyWhitelist, filterList);
+        } else {
+            config.put(keyRUserPropertyBlacklist, filterList);
+        }
+        return this;
+    }
+
+    ServerConfigBuilder segmentationFilterList(Set<String> filterList, boolean isWhitelist) {
+        if (isWhitelist) {
+            config.put(keyRSegmentationWhitelist, filterList);
+        } else {
+            config.put(keyRSegmentationBlacklist, filterList);
+        }
+        return this;
+    }
+
+    ServerConfigBuilder eventSegmentationFilterMap(Map<String, Set<String>> filterMap, boolean isWhitelist) {
+        if (isWhitelist) {
+            config.put(keyREventSegmentationWhitelist, filterMap);
+        } else {
+            config.put(keyREventSegmentationBlacklist, filterMap);
+        }
+        return this;
+    }
+
     ServerConfigBuilder defaults() {
         // Feature flags
         tracking(true);
@@ -198,6 +252,12 @@ ServerConfigBuilder defaults() {
         breadcrumbLimit(Countly.maxBreadcrumbCountDefault);
         traceLengthLimit(Countly.maxStackTraceLineLengthDefault);
         traceLinesLimit(Countly.maxStackTraceLinesPerThreadDefault);
+        userPropertyCacheLimit(100);
+
+        eventFilterList(new HashSet<>(), false);
+        userPropertyFilterList(new HashSet<>(), false);
+        segmentationFilterList(new HashSet<>(), false);
+        eventSegmentationFilterMap(new ConcurrentHashMap<>(), false);
 
         return this;
     }
@@ -221,6 +281,7 @@ void validateAgainst(Countly countly) {
         validateFeatureFlags(countly);
         validateIntervalsAndSizes(countly);
         validateLimits(countly);
+        validateFilterSettings(countly);
     }
 
     private void validateFeatureFlags(Countly countly) {
@@ -260,5 +321,32 @@ private void validateLimits(Countly countly) {
         Assert.assertEquals(config.get(keyRLimitBreadcrumb), countly.config_.sdkInternalLimits.maxBreadcrumbCount);
         Assert.assertEquals(config.get(keyRLimitTraceLength), countly.config_.sdkInternalLimits.maxStackTraceLineLength);
         Assert.assertEquals(config.get(keyRLimitTraceLine), countly.config_.sdkInternalLimits.maxStackTraceLinesPerThread);
+        Assert.assertEquals(config.get(keyRUserPropertyCacheLimit), countly.moduleConfiguration.getUserPropertyCacheLimit());
+    }
+
+    private void validateFilterSettings(Countly countly) {
+        Set<String> eventFilterList = (Set<String>) config.get(keyREventBlacklist);
+        if (eventFilterList == null) {
+            eventFilterList = (Set<String>) config.get(keyREventWhitelist);
+        }
+        Assert.assertEquals(Objects.requireNonNull(eventFilterList).toString(), countly.moduleConfiguration.getEventFilterList().filterList.toString());
+
+        Set<String> userPropertyFilterList = (Set<String>) config.get(keyRUserPropertyBlacklist);
+        if (userPropertyFilterList == null) {
+            userPropertyFilterList = (Set<String>) config.get(keyRUserPropertyWhitelist);
+        }
+        Assert.assertEquals(Objects.requireNonNull(userPropertyFilterList).toString(), countly.moduleConfiguration.getUserPropertyFilterList().filterList.toString());
+
+        Set<String> segmentationFilterList = (Set<String>) config.get(keyRSegmentationBlacklist);
+        if (segmentationFilterList == null) {
+            segmentationFilterList = (Set<String>) config.get(keyRSegmentationWhitelist);
+        }
+        Assert.assertEquals(Objects.requireNonNull(segmentationFilterList).toString(), countly.moduleConfiguration.getSegmentationFilterList().filterList.toString());
+
+        Map<String, Set<String>> eventSegmentationFilterMap = (Map<String, Set<String>>) config.get(keyREventSegmentationBlacklist);
+        if (eventSegmentationFilterMap == null) {
+            eventSegmentationFilterMap = (Map<String, Set<String>>) config.get(keyREventSegmentationWhitelist);
+        }
+        Assert.assertEquals(Objects.requireNonNull(eventSegmentationFilterMap).toString(), countly.moduleConfiguration.getEventSegmentationFilterList().filterList.toString());
     }
 } 

sdk/src/main/java/ly/count/android/sdk/ConfigurationProvider.java

@@ -1,5 +1,8 @@
 package ly.count.android.sdk;
 
+import java.util.Map;
+import java.util.Set;
+
 interface ConfigurationProvider {
     boolean getNetworkingEnabled();
 
@@ -31,4 +34,26 @@ interface ConfigurationProvider {
     int getBOMDuration();
 
     int getRequestTimeoutDurationMillis();
+
+    int getUserPropertyCacheLimit();
+
+    // LISTING FILTERS
+
+    FilterList<Set<String>> getEventFilterList();
+
+    FilterList<Set<String>> getUserPropertyFilterList();
+
+    FilterList<Set<String>> getSegmentationFilterList();
+
+    FilterList<Map<String, Set<String>>> getEventSegmentationFilterList();
+
+    class FilterList<T> {
+        T filterList;
+        boolean isWhitelist;
+
+        FilterList(T filterList, boolean isWhitelist) {
+            this.filterList = filterList;
+            this.isWhitelist = isWhitelist;
+        }
+    }
 }