diff --git a/splitio_android/android/src/main/java/io/split/splitio/Constants.java b/splitio_android/android/src/main/java/io/split/splitio/Constants.java
index 35ceb63..4537843 100644
--- a/splitio_android/android/src/main/java/io/split/splitio/Constants.java
+++ b/splitio_android/android/src/main/java/io/split/splitio/Constants.java
@@ -15,6 +15,10 @@ static class Method {
         static final String GET_TREATMENTS = "getTreatments";
         static final String GET_TREATMENT_WITH_CONFIG = "getTreatmentWithConfig";
         static final String GET_TREATMENTS_WITH_CONFIG = "getTreatmentsWithConfig";
+        static final String GET_TREATMENTS_BY_FLAG_SET = "getTreatmentsByFlagSet";
+        static final String GET_TREATMENTS_BY_FLAG_SETS = "getTreatmentsByFlagSets";
+        static final String GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET = "getTreatmentsWithConfigByFlagSet";
+        static final String GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS = "getTreatmentsWithConfigByFlagSets";
         static final String TRACK = "track";
         static final String GET_ATTRIBUTE = "getAttribute";
         static final String GET_ALL_ATTRIBUTES = "getAllAttributes";
@@ -42,6 +46,8 @@ static class Argument {
         static final String VALUE = "value";
         static final String PROPERTIES = "properties";
         static final String ATTRIBUTE_NAME = "attributeName";
+        static final String FLAG_SET = "flagSet";
+        static final String FLAG_SETS = "flagSets";
     }
 
     static class Error {
diff --git a/splitio_android/android/src/main/java/io/split/splitio/SplitMethodParserImpl.java b/splitio_android/android/src/main/java/io/split/splitio/SplitMethodParserImpl.java
index fb3ad5d..812143c 100644
--- a/splitio_android/android/src/main/java/io/split/splitio/SplitMethodParserImpl.java
+++ b/splitio_android/android/src/main/java/io/split/splitio/SplitMethodParserImpl.java
@@ -5,6 +5,8 @@
 import static io.split.splitio.Constants.Argument.ATTRIBUTE_NAME;
 import static io.split.splitio.Constants.Argument.BUCKETING_KEY;
 import static io.split.splitio.Constants.Argument.EVENT_TYPE;
+import static io.split.splitio.Constants.Argument.FLAG_SET;
+import static io.split.splitio.Constants.Argument.FLAG_SETS;
 import static io.split.splitio.Constants.Argument.MATCHING_KEY;
 import static io.split.splitio.Constants.Argument.PROPERTIES;
 import static io.split.splitio.Constants.Argument.SDK_CONFIGURATION;
@@ -25,7 +27,11 @@
 import static io.split.splitio.Constants.Method.GET_ATTRIBUTE;
 import static io.split.splitio.Constants.Method.GET_TREATMENT;
 import static io.split.splitio.Constants.Method.GET_TREATMENTS;
+import static io.split.splitio.Constants.Method.GET_TREATMENTS_BY_FLAG_SET;
+import static io.split.splitio.Constants.Method.GET_TREATMENTS_BY_FLAG_SETS;
 import static io.split.splitio.Constants.Method.GET_TREATMENTS_WITH_CONFIG;
+import static io.split.splitio.Constants.Method.GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET;
+import static io.split.splitio.Constants.Method.GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS;
 import static io.split.splitio.Constants.Method.GET_TREATMENT_WITH_CONFIG;
 import static io.split.splitio.Constants.Method.GET_USER_CONSENT;
 import static io.split.splitio.Constants.Method.INIT;
@@ -132,6 +138,34 @@ public void onMethodCall(String methodName, Object arguments, @NonNull MethodCha
                         mArgumentParser.getStringListArgument(SPLIT_NAME, arguments),
                         mArgumentParser.getMapArgument(ATTRIBUTES, arguments)));
                 break;
+            case GET_TREATMENTS_BY_FLAG_SET:
+                result.success(getTreatmentsByFlagSet(
+                        mArgumentParser.getStringArgument(MATCHING_KEY, arguments),
+                        mArgumentParser.getStringArgument(BUCKETING_KEY, arguments),
+                        mArgumentParser.getStringArgument(FLAG_SET, arguments),
+                        mArgumentParser.getMapArgument(ATTRIBUTES, arguments)));
+                break;
+            case GET_TREATMENTS_BY_FLAG_SETS:
+                result.success(getTreatmentsByFlagSets(
+                        mArgumentParser.getStringArgument(MATCHING_KEY, arguments),
+                        mArgumentParser.getStringArgument(BUCKETING_KEY, arguments),
+                        mArgumentParser.getStringListArgument(FLAG_SETS, arguments),
+                        mArgumentParser.getMapArgument(ATTRIBUTES, arguments)));
+                break;
+            case GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET:
+                result.success(getTreatmentsWithConfigByFlagSet(
+                        mArgumentParser.getStringArgument(MATCHING_KEY, arguments),
+                        mArgumentParser.getStringArgument(BUCKETING_KEY, arguments),
+                        mArgumentParser.getStringArgument(FLAG_SET, arguments),
+                        mArgumentParser.getMapArgument(ATTRIBUTES, arguments)));
+                break;
+            case GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS:
+                result.success(getTreatmentsWithConfigByFlagSets(
+                        mArgumentParser.getStringArgument(MATCHING_KEY, arguments),
+                        mArgumentParser.getStringArgument(BUCKETING_KEY, arguments),
+                        mArgumentParser.getStringListArgument(FLAG_SETS, arguments),
+                        mArgumentParser.getMapArgument(ATTRIBUTES, arguments)));
+                break;
             case TRACK:
                 result.success(track(
                         mArgumentParser.getStringArgument(MATCHING_KEY, arguments),
@@ -270,13 +304,41 @@ private Map<String, Map<String, String>> getTreatmentsWithConfig(
             List<String> splitNames,
             Map<String, Object> attributes) {
         Map<String, SplitResult> treatmentsWithConfig = mSplitWrapper.getTreatmentsWithConfig(matchingKey, bucketingKey, splitNames, attributes);
-        Map<String, Map<String, String>> resultMap = new HashMap<>();
+        return mapToSplitResults(treatmentsWithConfig);
+    }
 
-        for (Map.Entry<String, SplitResult> entry : treatmentsWithConfig.entrySet()) {
-            resultMap.put(entry.getKey(), getSplitResultMap(entry.getValue()));
-        }
+    private Map<String, String> getTreatmentsByFlagSet(
+            String matchingKey,
+            String bucketingKey,
+            String flagSet,
+            Map<String, Object> attributes) {
+        return mSplitWrapper.getTreatmentsByFlagSet(matchingKey, bucketingKey, flagSet, attributes);
+    }
 
-        return resultMap;
+    private Map<String, String> getTreatmentsByFlagSets(
+            String matchingKey,
+            String bucketingKey,
+            List<String> flagSets,
+            Map<String, Object> attributes) {
+        return mSplitWrapper.getTreatmentsByFlagSets(matchingKey, bucketingKey, flagSets, attributes);
+    }
+
+    private Map<String, Map<String, String>> getTreatmentsWithConfigByFlagSet(
+            String matchingKey,
+            String bucketingKey,
+            String flagSet,
+            Map<String, Object> attributes) {
+        Map<String, SplitResult> treatmentsWithConfig = mSplitWrapper.getTreatmentsWithConfigByFlagSet(matchingKey, bucketingKey, flagSet, attributes);
+        return mapToSplitResults(treatmentsWithConfig);
+    }
+
+    private Map<String, Map<String, String>> getTreatmentsWithConfigByFlagSets(
+            String matchingKey,
+            String bucketingKey,
+            List<String> flagSets,
+            Map<String, Object> attributes) {
+        Map<String, SplitResult> treatmentsWithConfig = mSplitWrapper.getTreatmentsWithConfigByFlagSets(matchingKey, bucketingKey, flagSets, attributes);
+        return mapToSplitResults(treatmentsWithConfig);
     }
 
     private boolean track(String matchingKey,
@@ -356,6 +418,21 @@ private static void invokeCallback(MethodChannel methodChannel, String matchingK
         methodChannel.invokeMethod(methodName, arguments);
     }
 
+    @NonNull
+    private static Map<String, Map<String, String>> mapToSplitResults(Map<String, SplitResult> treatmentsWithConfig) {
+        Map<String, Map<String, String>> resultMap = new HashMap<>();
+
+        if (treatmentsWithConfig == null) {
+            return resultMap;
+        }
+
+        for (Map.Entry<String, SplitResult> entry : treatmentsWithConfig.entrySet()) {
+            resultMap.put(entry.getKey(), getSplitResultMap(entry.getValue()));
+        }
+
+        return resultMap;
+    }
+
     private static Map<String, String> getSplitResultMap(SplitResult splitResult) {
         if (splitResult == null) {
             return new HashMap<>();
@@ -395,6 +472,8 @@ private static Map<String, Object> getSplitViewAsMap(@Nullable SplitView splitVi
         splitViewMap.put("treatments", splitView.treatments);
         splitViewMap.put("changeNumber", splitView.changeNumber);
         splitViewMap.put("configs", splitView.configs);
+        splitViewMap.put("defaultTreatment", splitView.defaultTreatment);
+        splitViewMap.put("sets", splitView.sets);
 
         return splitViewMap;
     }
diff --git a/splitio_android/android/src/test/java/io/split/splitio/SplitMethodParserImplTest.java b/splitio_android/android/src/test/java/io/split/splitio/SplitMethodParserImplTest.java
index 538ea0e..7f7a225 100644
--- a/splitio_android/android/src/test/java/io/split/splitio/SplitMethodParserImplTest.java
+++ b/splitio_android/android/src/test/java/io/split/splitio/SplitMethodParserImplTest.java
@@ -504,4 +504,92 @@ public void setUserConsentDisabled() {
         verify(mResult).success(null);
         verify(mSplitWrapper).setUserConsent(false);
     }
+
+    @Test
+    public void getTreatmentsByFlagSetWorksCorrectly() {
+        Map<String, Object> map = new HashMap<>();
+        map.put("matchingKey", "user-key");
+        map.put("bucketingKey", "bucketing-key");
+        map.put("flagSet", "set_1");
+        map.put("attributes", Collections.singletonMap("age", 10));
+
+        when(mArgumentParser.getStringArgument("matchingKey", map)).thenReturn("user-key");
+        when(mArgumentParser.getStringArgument("bucketingKey", map)).thenReturn("bucketing-key");
+        when(mArgumentParser.getStringArgument("flagSet", map)).thenReturn("set_1");
+        when(mArgumentParser.getMapArgument("attributes", map)).thenReturn(Collections.singletonMap("age", 10));
+        when(mSplitWrapper.getTreatmentsByFlagSet(any(), any(), any(), any())).thenReturn(Collections.singletonMap("flag_1", "on"));
+
+        mMethodParser.onMethodCall("getTreatmentsByFlagSet", map, mResult);
+
+        verify(mSplitWrapper).getTreatmentsByFlagSet("user-key", "bucketing-key", "set_1", Collections.singletonMap("age", 10));
+        verify(mResult).success(Collections.singletonMap("flag_1", "on"));
+    }
+
+    @Test
+    public void getTreatmentsByFlagSetsWorksCorrectly() {
+        Map<String, Object> map = new HashMap<>();
+        map.put("matchingKey", "user-key");
+        map.put("bucketingKey", "bucketing-key");
+        map.put("flagSets", Arrays.asList("set_1", "set_2"));
+        map.put("attributes", Collections.singletonMap("age", 10));
+
+        when(mArgumentParser.getStringArgument("matchingKey", map)).thenReturn("user-key");
+        when(mArgumentParser.getStringArgument("bucketingKey", map)).thenReturn("bucketing-key");
+        when(mArgumentParser.getStringListArgument("flagSets", map)).thenReturn(Arrays.asList("set_1", "set_2"));
+        when(mArgumentParser.getMapArgument("attributes", map)).thenReturn(Collections.singletonMap("age", 10));
+        when(mSplitWrapper.getTreatmentsByFlagSets(any(), any(), any(), any())).thenReturn(Collections.singletonMap("flag_1", "on"));
+
+        mMethodParser.onMethodCall("getTreatmentsByFlagSets", map, mResult);
+
+        verify(mSplitWrapper).getTreatmentsByFlagSets("user-key", "bucketing-key", Arrays.asList("set_1", "set_2"), Collections.singletonMap("age", 10));
+        verify(mResult).success(Collections.singletonMap("flag_1", "on"));
+    }
+
+    @Test
+    public void getTreatmentsWithConfigByFlagSetWorksCorrectly() {
+        Map<String, Object> map = new HashMap<>();
+        map.put("matchingKey", "user-key");
+        map.put("bucketingKey", "bucketing-key");
+        map.put("flagSet", "set_1");
+        map.put("attributes", Collections.singletonMap("age", 10));
+
+        Map<String, String> resultMap1 = new HashMap<>();
+        resultMap1.put("treatment", "on");
+        resultMap1.put("config", "{config}");
+
+        when(mArgumentParser.getStringArgument("matchingKey", map)).thenReturn("user-key");
+        when(mArgumentParser.getStringArgument("bucketingKey", map)).thenReturn("bucketing-key");
+        when(mArgumentParser.getStringArgument("flagSet", map)).thenReturn("set_1");
+        when(mArgumentParser.getMapArgument("attributes", map)).thenReturn(Collections.singletonMap("age", 10));
+        when(mSplitWrapper.getTreatmentsWithConfigByFlagSet(any(), any(), any(), any())).thenReturn(Collections.singletonMap("flag_1", new SplitResult("on", "{config}")));
+
+        mMethodParser.onMethodCall("getTreatmentsWithConfigByFlagSet", map, mResult);
+
+        verify(mSplitWrapper).getTreatmentsWithConfigByFlagSet("user-key", "bucketing-key", "set_1", Collections.singletonMap("age", 10));
+        verify(mResult).success(Collections.singletonMap("flag_1", resultMap1));
+    }
+
+    @Test
+    public void getTreatmentsWithConfigByFlagSetsWorksCorrectly() {
+        Map<String, Object> map = new HashMap<>();
+        map.put("matchingKey", "user-key");
+        map.put("bucketingKey", "bucketing-key");
+        map.put("flagSets", Arrays.asList("set_1", "set_2"));
+        map.put("attributes", Collections.singletonMap("age", 10));
+
+        Map<String, String> resultMap1 = new HashMap<>();
+        resultMap1.put("treatment", "on");
+        resultMap1.put("config", "{config}");
+
+        when(mArgumentParser.getStringArgument("matchingKey", map)).thenReturn("user-key");
+        when(mArgumentParser.getStringArgument("bucketingKey", map)).thenReturn("bucketing-key");
+        when(mArgumentParser.getStringListArgument("flagSets", map)).thenReturn(Arrays.asList("set_1", "set_2"));
+        when(mArgumentParser.getMapArgument("attributes", map)).thenReturn(Collections.singletonMap("age", 10));
+        when(mSplitWrapper.getTreatmentsWithConfigByFlagSets(any(), any(), any(), any())).thenReturn(Collections.singletonMap("flag_1", new SplitResult("on", "{config}")));
+
+        mMethodParser.onMethodCall("getTreatmentsWithConfigByFlagSets", map, mResult);
+
+        verify(mSplitWrapper).getTreatmentsWithConfigByFlagSets("user-key", "bucketing-key", Arrays.asList("set_1", "set_2"), Collections.singletonMap("age", 10));
+        verify(mResult).success(Collections.singletonMap("flag_1", resultMap1));
+    }
 }
diff --git a/splitio_platform_interface/lib/split_view.dart b/splitio_platform_interface/lib/split_view.dart
index 40451c5..023ec0a 100644
--- a/splitio_platform_interface/lib/split_view.dart
+++ b/splitio_platform_interface/lib/split_view.dart
@@ -32,7 +32,7 @@ class SplitView {
         entry['changeNumber'],
         mappedConfig,
         entry['defaultTreatment'] ?? '',
-        entry['sets'] ?? []);
+        (entry['sets'] ?? [] as List).map((el) => el as String).toList());
   }
 
   @override