Add system APIs to configure and disable MSCS

in the supplicant.

Bug: 300870302
Bug: 318008418
Test: m
Change-Id: I3d7209a901d8ae46e2f8a98d3eb8ba4b3cf0d9ab

7 files changed, 418 insertions, 0 deletions

diff --git a/flags/wifi_flags.aconfig b/flags/wifi_flags.aconfig
index a35702ca92..eaf67a6dc0 100644
--- a/flags/wifi_flags.aconfig
+++ b/flags/wifi_flags.aconfig
@@ -112,3 +112,10 @@ flag {
     description: "Add new API to set the subscription id in the Wifi Info"
     bug: "236669534"
 }
+
+flag {
+    name: "mscs_configuration"
+    namespace: "wifi"
+    description: "Add new API to configure MSCS in the supplicant"
+    bug: "300870302"
+}
diff --git a/framework/aidl-export/android/net/wifi/MscsParams.aidl b/framework/aidl-export/android/net/wifi/MscsParams.aidl
new file mode 100644
index 0000000000..96d378bc9d
--- /dev/null
+++ b/framework/aidl-export/android/net/wifi/MscsParams.aidl
@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2023, The Android Open Source Project
+ *
+ * Licensed 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 android.net.wifi;
+
+parcelable MscsParams;
diff --git a/framework/api/system-current.txt b/framework/api/system-current.txt
index 0866e6e7ae..d1d712d23d 100644
--- a/framework/api/system-current.txt
+++ b/framework/api/system-current.txt
@@ -29,6 +29,33 @@ package android.net.wifi {
     field public static final int EASY_CONNECT_EVENT_SUCCESS_CONFIGURATION_SENT = 0; // 0x0
   }
 
+  @FlaggedApi("com.android.wifi.flags.mscs_configuration") public final class MscsParams implements android.os.Parcelable {
+    method @FlaggedApi("com.android.wifi.flags.mscs_configuration") public int describeContents();
+    method @FlaggedApi("com.android.wifi.flags.mscs_configuration") public int getFrameClassifierFields();
+    method @FlaggedApi("com.android.wifi.flags.mscs_configuration") @IntRange(from=0, to=0x3938700) public int getStreamTimeoutUs();
+    method @FlaggedApi("com.android.wifi.flags.mscs_configuration") public int getUserPriorityBitmap();
+    method @FlaggedApi("com.android.wifi.flags.mscs_configuration") @IntRange(from=0, to=7) public int getUserPriorityLimit();
+    method @FlaggedApi("com.android.wifi.flags.mscs_configuration") public void writeToParcel(@NonNull android.os.Parcel, int);
+    field @FlaggedApi("com.android.wifi.flags.mscs_configuration") @NonNull public static final android.os.Parcelable.Creator<android.net.wifi.MscsParams> CREATOR;
+    field @FlaggedApi("com.android.wifi.flags.mscs_configuration") public static final int FRAME_CLASSIFIER_DSCP = 32; // 0x20
+    field @FlaggedApi("com.android.wifi.flags.mscs_configuration") public static final int FRAME_CLASSIFIER_DST_IP_ADDR = 4; // 0x4
+    field @FlaggedApi("com.android.wifi.flags.mscs_configuration") public static final int FRAME_CLASSIFIER_DST_PORT = 16; // 0x10
+    field @FlaggedApi("com.android.wifi.flags.mscs_configuration") public static final int FRAME_CLASSIFIER_FLOW_LABEL = 128; // 0x80
+    field @FlaggedApi("com.android.wifi.flags.mscs_configuration") public static final int FRAME_CLASSIFIER_IP_VERSION = 1; // 0x1
+    field @FlaggedApi("com.android.wifi.flags.mscs_configuration") public static final int FRAME_CLASSIFIER_PROTOCOL_NEXT_HDR = 64; // 0x40
+    field @FlaggedApi("com.android.wifi.flags.mscs_configuration") public static final int FRAME_CLASSIFIER_SRC_IP_ADDR = 2; // 0x2
+    field @FlaggedApi("com.android.wifi.flags.mscs_configuration") public static final int FRAME_CLASSIFIER_SRC_PORT = 8; // 0x8
+  }
+
+  @FlaggedApi("com.android.wifi.flags.mscs_configuration") public static final class MscsParams.Builder {
+    ctor @FlaggedApi("com.android.wifi.flags.mscs_configuration") public MscsParams.Builder();
+    method @FlaggedApi("com.android.wifi.flags.mscs_configuration") @NonNull public android.net.wifi.MscsParams build();
+    method @FlaggedApi("com.android.wifi.flags.mscs_configuration") @NonNull public android.net.wifi.MscsParams.Builder setFrameClassifierFields(int);
+    method @FlaggedApi("com.android.wifi.flags.mscs_configuration") @NonNull public android.net.wifi.MscsParams.Builder setStreamTimeoutUs(@IntRange(from=0, to=0x3938700) int);
+    method @FlaggedApi("com.android.wifi.flags.mscs_configuration") @NonNull public android.net.wifi.MscsParams.Builder setUserPriorityBitmap(int);
+    method @FlaggedApi("com.android.wifi.flags.mscs_configuration") @NonNull public android.net.wifi.MscsParams.Builder setUserPriorityLimit(@IntRange(from=0, to=7) int);
+  }
+
   @FlaggedApi("com.android.wifi.flags.vendor_parcelable_parameters") public final class OuiKeyedData implements android.os.Parcelable {
     method @FlaggedApi("com.android.wifi.flags.vendor_parcelable_parameters") public int describeContents();
     method @FlaggedApi("com.android.wifi.flags.vendor_parcelable_parameters") @NonNull public android.os.PersistableBundle getData();
@@ -617,6 +644,8 @@ package android.net.wifi {
     method @RequiresPermission(anyOf={android.Manifest.permission.NETWORK_SETTINGS, android.Manifest.permission.NETWORK_SETUP_WIZARD, android.Manifest.permission.NETWORK_STACK}) public void connect(int, @Nullable android.net.wifi.WifiManager.ActionListener);
     method @Deprecated @RequiresPermission(anyOf={android.Manifest.permission.NETWORK_SETTINGS, android.Manifest.permission.NETWORK_SETUP_WIZARD, android.Manifest.permission.NETWORK_STACK}) public void disable(int, @Nullable android.net.wifi.WifiManager.ActionListener);
     method @RequiresPermission(anyOf={android.Manifest.permission.NETWORK_SETTINGS, android.Manifest.permission.NETWORK_STACK}) public void disableEphemeralNetwork(@NonNull String);
+    method @FlaggedApi("com.android.wifi.flags.mscs_configuration") @RequiresPermission(anyOf={android.Manifest.permission.MANAGE_WIFI_NETWORK_SELECTION}) public void disableMscs();
+    method @FlaggedApi("com.android.wifi.flags.mscs_configuration") @RequiresPermission(anyOf={android.Manifest.permission.MANAGE_WIFI_NETWORK_SELECTION}) public void enableMscs(@NonNull android.net.wifi.MscsParams);
     method @RequiresPermission(android.Manifest.permission.NETWORK_SETTINGS) public void factoryReset();
     method @RequiresPermission(anyOf={android.Manifest.permission.NETWORK_SETTINGS, android.Manifest.permission.NETWORK_SETUP_WIZARD, android.Manifest.permission.NETWORK_STACK}) public void forget(int, @Nullable android.net.wifi.WifiManager.ActionListener);
     method @NonNull @RequiresPermission(anyOf={android.Manifest.permission.NETWORK_SETTINGS, android.Manifest.permission.NETWORK_SETUP_WIZARD}) public java.util.List<android.util.Pair<android.net.wifi.WifiConfiguration,java.util.Map<java.lang.Integer,java.util.List<android.net.wifi.ScanResult>>>> getAllMatchingWifiConfigs(@NonNull java.util.List<android.net.wifi.ScanResult>);
diff --git a/framework/java/android/net/wifi/BaseWifiService.java b/framework/java/android/net/wifi/BaseWifiService.java
index 7dc7caccc7..d65eb993d7 100644
--- a/framework/java/android/net/wifi/BaseWifiService.java
+++ b/framework/java/android/net/wifi/BaseWifiService.java
@@ -1103,4 +1103,14 @@ public class BaseWifiService extends IWifiManager.Stub {
     public void queryWepAllowed(@NonNull IBooleanListener listener) {
         throw new UnsupportedOperationException();
     }
+
+    @Override
+    public void enableMscs(@NonNull MscsParams mscsParams) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void disableMscs() {
+        throw new UnsupportedOperationException();
+    }
 }
diff --git a/framework/java/android/net/wifi/IWifiManager.aidl b/framework/java/android/net/wifi/IWifiManager.aidl
index 6e62c226fa..c946c20c62 100644
--- a/framework/java/android/net/wifi/IWifiManager.aidl
+++ b/framework/java/android/net/wifi/IWifiManager.aidl
@@ -52,6 +52,7 @@ import android.net.wifi.IWifiConnectedNetworkScorer;
 import android.net.wifi.IWifiLowLatencyLockListener;
 import android.net.wifi.IWifiNetworkSelectionConfigListener;
 import android.net.wifi.IWifiVerboseLoggingStatusChangedListener;
+import android.net.wifi.MscsParams;
 import android.net.wifi.QosPolicyParams;
 import android.net.wifi.ScanResult;
 import android.net.wifi.SoftApConfiguration;
@@ -472,4 +473,8 @@ interface IWifiManager
     void setWepAllowed(boolean isAllowed);
 
     void queryWepAllowed(in IBooleanListener listener);
+
+    void enableMscs(in MscsParams mscsParams);
+
+    void disableMscs();
 }
diff --git a/framework/java/android/net/wifi/MscsParams.java b/framework/java/android/net/wifi/MscsParams.java
new file mode 100644
index 0000000000..67deb3d622
--- /dev/null
+++ b/framework/java/android/net/wifi/MscsParams.java
@@ -0,0 +1,304 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed 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 android.net.wifi;
+
+import android.annotation.FlaggedApi;
+import android.annotation.IntDef;
+import android.annotation.IntRange;
+import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.annotation.SystemApi;
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.Objects;
+
+/**
+ * Mirrored Stream Classification Service (MSCS) parameters.
+ * Refer to section 3.1 of the Wi-Fi QoS Management Specification v3.0.
+ * @hide
+ */
+@SystemApi
+@FlaggedApi("com.android.wifi.flags.mscs_configuration")
+public final class MscsParams implements Parcelable {
+    /** IP version used by the traffic stream */
+    @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+    public static final int FRAME_CLASSIFIER_IP_VERSION = 1 << 0;
+
+    /** Source IP address used by the traffic stream */
+    @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+    public static final int FRAME_CLASSIFIER_SRC_IP_ADDR = 1 << 1;
+
+    /** Destination IP address used by the traffic stream */
+    @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+    public static final int FRAME_CLASSIFIER_DST_IP_ADDR = 1 << 2;
+
+    /** Source port used by the traffic stream */
+    @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+    public static final int FRAME_CLASSIFIER_SRC_PORT = 1 << 3;
+
+    /** Destination port used by the traffic stream */
+    @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+    public static final int FRAME_CLASSIFIER_DST_PORT = 1 << 4;
+
+    /** DSCP value used by the traffic stream */
+    @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+    public static final int FRAME_CLASSIFIER_DSCP = 1 << 5;
+
+    /** Indicates Protocol if using IPv4, or Next Header if using IPv6 */
+    @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+    public static final int FRAME_CLASSIFIER_PROTOCOL_NEXT_HDR = 1 << 6;
+
+    /** Flow label. Only applicable if using IPv6 */
+    @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+    public static final int FRAME_CLASSIFIER_FLOW_LABEL = 1 << 7;
+
+    /** @hide */
+    @Retention(RetentionPolicy.SOURCE)
+    @IntDef(flag = true, prefix = { "FRAME_CLASSIFIER_" }, value = {
+            FRAME_CLASSIFIER_IP_VERSION,
+            FRAME_CLASSIFIER_SRC_IP_ADDR,
+            FRAME_CLASSIFIER_DST_IP_ADDR,
+            FRAME_CLASSIFIER_SRC_PORT,
+            FRAME_CLASSIFIER_DST_PORT,
+            FRAME_CLASSIFIER_DSCP,
+            FRAME_CLASSIFIER_PROTOCOL_NEXT_HDR,
+            FRAME_CLASSIFIER_FLOW_LABEL,
+    })
+    public @interface FrameClassifierField {}
+
+    /** @hide */
+    public static final int DEFAULT_FRAME_CLASSIFIER_FIELDS =
+            FRAME_CLASSIFIER_IP_VERSION
+                | FRAME_CLASSIFIER_SRC_IP_ADDR
+                | FRAME_CLASSIFIER_DST_IP_ADDR
+                | FRAME_CLASSIFIER_SRC_PORT
+                | FRAME_CLASSIFIER_DST_PORT
+                | FRAME_CLASSIFIER_PROTOCOL_NEXT_HDR;
+    /** @hide */
+    public static final int DEFAULT_USER_PRIORITY_BITMAP = (1 << 6) | (1 << 7);
+    /** @hide */
+    public static final int DEFAULT_USER_PRIORITY_LIMIT = 7;   // keep the original priority
+    /** @hide */
+    public static final int MAX_STREAM_TIMEOUT_US = 60_000_000;    // 60 seconds
+
+    private final int mFrameClassifierFields;
+    private final int mUserPriorityBitmap;
+    private final int mUserPriorityLimit;
+    private final int mStreamTimeoutUs;
+
+    private MscsParams(int frameClassifierFields, int userPriorityBitmap,
+            int userPriorityLimit, int streamTimeoutUs) {
+        mFrameClassifierFields = frameClassifierFields;
+        mUserPriorityBitmap = userPriorityBitmap;
+        mUserPriorityLimit = userPriorityLimit;
+        mStreamTimeoutUs = streamTimeoutUs;
+    }
+
+    /**
+     * Get the frame classifier fields bitmap.
+     * See {@link Builder#setFrameClassifierFields(int)}
+     *
+     * @return Bitmap of {@link FrameClassifierField} represented as an int.
+     */
+    @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+    public @FrameClassifierField int getFrameClassifierFields() {
+        return mFrameClassifierFields;
+    }
+
+    /**
+     * Get the user priority bitmap. See {@link Builder#setUserPriorityBitmap(int)}
+     *
+     * @return Bitmap of user priorities represented as an int.
+     */
+    @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+    public int getUserPriorityBitmap() {
+        return mUserPriorityBitmap;
+    }
+
+    /**
+     * Get the user priority limit. See {@link Builder#setUserPriorityLimit(int)}
+     *
+     * @return User priority limit.
+     */
+    @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+    @IntRange(from = 0, to = 7)
+    public int getUserPriorityLimit() {
+        return mUserPriorityLimit;
+    }
+
+    /**
+     * Get the stream timeout in microseconds. See {@link Builder#setStreamTimeoutUs(int)}
+     *
+     * @return Stream timeout in microseconds.
+     */
+    @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+    @IntRange(from = 0, to = MAX_STREAM_TIMEOUT_US)
+    public int getStreamTimeoutUs() {
+        return mStreamTimeoutUs;
+    }
+
+    @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+    @Override
+    public boolean equals(@Nullable Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        MscsParams that = (MscsParams) o;
+        return mFrameClassifierFields == that.mFrameClassifierFields
+                && mUserPriorityBitmap == that.mUserPriorityBitmap
+                && mUserPriorityLimit == that.mUserPriorityLimit
+                && mStreamTimeoutUs == that.mStreamTimeoutUs;
+    }
+
+    @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+    @Override
+    public int hashCode() {
+        return Objects.hash(mFrameClassifierFields, mUserPriorityBitmap,
+                mUserPriorityLimit, mStreamTimeoutUs);
+    }
+
+    @Override
+    @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+    public int describeContents() {
+        return 0;
+    }
+
+    /** @hide */
+    @Override
+    @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+    public void writeToParcel(@NonNull Parcel dest, int flags) {
+        dest.writeInt(mFrameClassifierFields);
+        dest.writeInt(mUserPriorityBitmap);
+        dest.writeInt(mUserPriorityLimit);
+        dest.writeInt(mStreamTimeoutUs);
+    }
+
+    /** @hide */
+    MscsParams(@NonNull Parcel in) {
+        this.mFrameClassifierFields = in.readInt();
+        this.mUserPriorityBitmap = in.readInt();
+        this.mUserPriorityLimit = in.readInt();
+        this.mStreamTimeoutUs = in.readInt();
+    }
+
+    @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+    public static final @NonNull Parcelable.Creator<MscsParams> CREATOR =
+            new Parcelable.Creator<MscsParams>() {
+                @Override
+                public MscsParams createFromParcel(Parcel in) {
+                    return new MscsParams(in);
+                }
+
+                @Override
+                public MscsParams[] newArray(int size) {
+                    return new MscsParams[size];
+                }
+            };
+
+    /** Builder for {@link MscsParams}. */
+    @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+    public static final class Builder {
+        private int mFrameClassifierFields = DEFAULT_FRAME_CLASSIFIER_FIELDS;
+        private int mUserPriorityBitmap = DEFAULT_USER_PRIORITY_BITMAP;
+        private int mUserPriorityLimit = DEFAULT_USER_PRIORITY_LIMIT;
+        private int mStreamTimeoutUs = MAX_STREAM_TIMEOUT_US;
+
+        /**
+         * Constructor for {@link Builder}.
+         */
+        @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+        public Builder() {}
+
+        /**
+         * Sets a bitmap of {@link FrameClassifierField} indicating which TCLAS Type 4 frame
+         * classifier fields should be used to build a classifier.
+         *
+         * @param frameClassifierFields Bitmap indicating the requested fields.
+         */
+        @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+        @NonNull
+        public Builder setFrameClassifierFields(@FrameClassifierField int frameClassifierFields) {
+            if ((frameClassifierFields & 0xFFFFFF00) != 0) {
+                throw new IllegalArgumentException("frameClassifierFields can only use bits 0-7");
+            }
+            mFrameClassifierFields = frameClassifierFields;
+            return this;
+        }
+
+        /**
+         * Sets a bitmap indicating which User Priorities (UPs) should be classified using MSCS.
+         * The least significant bit corresponds to UP 0, and the most significant
+         * bit to UP 7. Setting a bit to 1 indicates that UP should be classified.
+         *
+         * @param userPriorityBitmap Bitmap indicating which UPs should be classified.
+         */
+        @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+        @NonNull
+        public Builder setUserPriorityBitmap(int userPriorityBitmap) {
+            if ((userPriorityBitmap & 0xFFFFFF00) != 0) {
+                throw new IllegalArgumentException("userPriorityBitmap can only use bits 0-7");
+            }
+            mUserPriorityBitmap = userPriorityBitmap;
+            return this;
+        }
+
+        /**
+         * Sets the maximum user priority that can be assigned using the MSCS service.
+         * Value must be between 0 and 7 (inclusive).
+         *
+         * @param userPriorityLimit Maximum user priority that can be assigned by MSCS.
+         */
+        @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+        @NonNull
+        public Builder setUserPriorityLimit(@IntRange(from = 0, to = 7) int userPriorityLimit) {
+            if (userPriorityLimit < 0 || userPriorityLimit > 7) {
+                throw new IllegalArgumentException(
+                        "userPriorityLimit must be between 0-7 (inclusive)");
+            }
+            mUserPriorityLimit = userPriorityLimit;
+            return this;
+        }
+
+        /**
+         * Set the minimum timeout (in microseconds) to keep this request in the MSCS list.
+         *
+         * @param streamTimeoutUs Minimum timeout in microseconds.
+         */
+        @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+        @NonNull
+        public Builder setStreamTimeoutUs(
+                @IntRange(from = 0, to = MAX_STREAM_TIMEOUT_US) int streamTimeoutUs) {
+            if (streamTimeoutUs < 0 || streamTimeoutUs > MAX_STREAM_TIMEOUT_US) {
+                throw new IllegalArgumentException("streamTimeoutUs must be 60 seconds or less");
+            }
+            mStreamTimeoutUs = streamTimeoutUs;
+            return this;
+        }
+
+        /**
+         * Construct an MscsParams object using the specified parameters.
+         */
+        @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+        @NonNull
+        public MscsParams build() {
+            return new MscsParams(mFrameClassifierFields, mUserPriorityBitmap,
+                    mUserPriorityLimit, mStreamTimeoutUs);
+        }
+    }
+}
diff --git a/framework/java/android/net/wifi/WifiManager.java b/framework/java/android/net/wifi/WifiManager.java
index 99db54e180..d47a4303dc 100644
--- a/framework/java/android/net/wifi/WifiManager.java
+++ b/framework/java/android/net/wifi/WifiManager.java
@@ -12089,4 +12089,48 @@ public class WifiManager {
             throw e.rethrowFromSystemServer();
         }
     }
+
+    /**
+     * Enable Mirrored Stream Classification Service (MSCS) and configure using
+     * the provided configuration values.
+     *
+     * If MSCS has already been enabled/configured, this will override the
+     * existing configuration.
+     *
+     * Note that this API should be considered best-effort.
+     *
+     * @param mscsParams {@link MscsParams} object containing the configuration parameters.
+     * @hide
+     */
+    @SystemApi
+    @RequiresApi(Build.VERSION_CODES.VANILLA_ICE_CREAM)
+    @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+    @RequiresPermission(anyOf = {MANAGE_WIFI_NETWORK_SELECTION})
+    public void enableMscs(@NonNull MscsParams mscsParams) {
+        Objects.requireNonNull(mscsParams);
+        try {
+            mService.enableMscs(mscsParams);
+        } catch (RemoteException e) {
+            throw e.rethrowFromSystemServer();
+        }
+    }
+
+    /**
+     * Disable Mirrored Stream Classification Service (MSCS).
+     *
+     * If MSCS is enabled/configured, this will send a remove request to the AP.
+     * Note that this API should be considered best-effort.
+     * @hide
+     */
+    @SystemApi
+    @RequiresApi(Build.VERSION_CODES.VANILLA_ICE_CREAM)
+    @FlaggedApi("com.android.wifi.flags.mscs_configuration")
+    @RequiresPermission(anyOf = {MANAGE_WIFI_NETWORK_SELECTION})
+    public void disableMscs() {
+        try {
+            mService.disableMscs();
+        } catch (RemoteException e) {
+            throw e.rethrowFromSystemServer();
+        }
+    }
 }