diff --git a/src/com/android/phone/CallWaitingSwitchPreference.java b/src/com/android/phone/CallWaitingSwitchPreference.java
index 41442fe..01dd3b2 100644
--- a/src/com/android/phone/CallWaitingSwitchPreference.java
+++ b/src/com/android/phone/CallWaitingSwitchPreference.java
@@ -1,18 +1,21 @@
 package com.android.phone;
 
+import static com.android.phone.TimeConsumingPreferenceActivity.EXCEPTION_ERROR;
 import static com.android.phone.TimeConsumingPreferenceActivity.RESPONSE_ERROR;
 
 import android.content.Context;
-import android.os.AsyncResult;
 import android.os.Handler;
 import android.os.Message;
 import android.preference.SwitchPreference;
+import android.telephony.TelephonyManager;
 import android.util.AttributeSet;
 import android.util.Log;
 
-import com.android.internal.telephony.CommandException;
 import com.android.internal.telephony.Phone;
 
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+
 public class CallWaitingSwitchPreference extends SwitchPreference {
     private static final String LOG_TAG = "CallWaitingSwitchPreference";
     private final boolean DBG = (PhoneGlobals.DBG_LEVEL >= 2);
@@ -20,6 +23,11 @@
     private final MyHandler mHandler = new MyHandler();
     private Phone mPhone;
     private TimeConsumingPreferenceListener mTcpListener;
+    private Executor mExecutor;
+    private TelephonyManager mTelephonyManager;
+    private boolean mIsDuringUpdateProcess = false;
+    private int mUpdateStatus = TelephonyManager.CALL_WAITING_STATUS_UNKNOWN_ERROR;
+    private int mQueryStatus = TelephonyManager.CALL_WAITING_STATUS_UNKNOWN_ERROR;
 
     public CallWaitingSwitchPreference(Context context, AttributeSet attrs, int defStyle) {
         super(context, attrs, defStyle);
@@ -37,101 +45,84 @@
             TimeConsumingPreferenceListener listener, boolean skipReading, Phone phone) {
         mPhone = phone;
         mTcpListener = listener;
+        mExecutor = Executors.newSingleThreadExecutor();
+        mTelephonyManager = getContext().getSystemService(
+                TelephonyManager.class).createForSubscriptionId(phone.getSubId());
 
         if (!skipReading) {
-            mPhone.getCallWaiting(mHandler.obtainMessage(MyHandler.MESSAGE_GET_CALL_WAITING,
-                    MyHandler.MESSAGE_GET_CALL_WAITING, MyHandler.MESSAGE_GET_CALL_WAITING));
+            Log.d(LOG_TAG, "init getCallWaitingStatus");
+            mTelephonyManager.getCallWaitingStatus(mExecutor, this::queryStatusCallBack);
             if (mTcpListener != null) {
                 mTcpListener.onStarted(this, true);
             }
         }
     }
 
+    private void queryStatusCallBack(int result) {
+        Log.d(LOG_TAG, "queryStatusCallBack: CW state " + result);
+        mQueryStatus = result;
+        mHandler.sendMessage(mHandler.obtainMessage(MyHandler.MESSAGE_UPDATE_CALL_WAITING));
+    }
+
+    private void updateStatusCallBack(int result) {
+        Log.d(LOG_TAG, "updateStatusCallBack: CW state " + result + ", and re get");
+        mUpdateStatus = result;
+        mTelephonyManager.getCallWaitingStatus(mExecutor, this::queryStatusCallBack);
+    }
+
     @Override
     protected void onClick() {
         super.onClick();
-
-        mPhone.setCallWaiting(isChecked(),
-                mHandler.obtainMessage(MyHandler.MESSAGE_SET_CALL_WAITING));
+        mTelephonyManager.setCallWaitingEnabled(isChecked(), mExecutor, this::updateStatusCallBack);
         if (mTcpListener != null) {
+            mIsDuringUpdateProcess = true;
             mTcpListener.onStarted(this, false);
         }
     }
 
     private class MyHandler extends Handler {
-        static final int MESSAGE_GET_CALL_WAITING = 0;
-        static final int MESSAGE_SET_CALL_WAITING = 1;
+        static final int MESSAGE_UPDATE_CALL_WAITING = 0;
 
         @Override
         public void handleMessage(Message msg) {
             switch (msg.what) {
-                case MESSAGE_GET_CALL_WAITING:
-                    handleGetCallWaitingResponse(msg);
-                    break;
-                case MESSAGE_SET_CALL_WAITING:
-                    handleSetCallWaitingResponse(msg);
+                case MESSAGE_UPDATE_CALL_WAITING:
+                    updateUi();
                     break;
             }
         }
 
-        private void handleGetCallWaitingResponse(Message msg) {
-            AsyncResult ar = (AsyncResult) msg.obj;
-
+        private void updateUi() {
             if (mTcpListener != null) {
-                if (msg.arg2 == MESSAGE_SET_CALL_WAITING) {
+                if (mIsDuringUpdateProcess) {
                     mTcpListener.onFinished(CallWaitingSwitchPreference.this, false);
                 } else {
                     mTcpListener.onFinished(CallWaitingSwitchPreference.this, true);
                 }
             }
 
-            if (ar.exception instanceof CommandException) {
-                if (DBG) {
-                    Log.d(LOG_TAG, "handleGetCallWaitingResponse: CommandException=" +
-                            ar.exception);
-                }
+            if (mIsDuringUpdateProcess && (
+                    mUpdateStatus == TelephonyManager.CALL_WAITING_STATUS_NOT_SUPPORTED
+                            || mUpdateStatus
+                            == TelephonyManager.CALL_WAITING_STATUS_UNKNOWN_ERROR)) {
+                Log.d(LOG_TAG, "handleSetCallWaitingResponse: Exception");
                 if (mTcpListener != null) {
-                    mTcpListener.onException(CallWaitingSwitchPreference.this,
-                            (CommandException)ar.exception);
+                    mTcpListener.onError(CallWaitingSwitchPreference.this, EXCEPTION_ERROR);
                 }
-            } else if (ar.userObj instanceof Throwable || ar.exception != null) {
-                // Still an error case but just not a CommandException.
-                if (DBG) {
-                    Log.d(LOG_TAG, "handleGetCallWaitingResponse: Exception" + ar.exception);
-                }
+            } else if (mQueryStatus == TelephonyManager.CALL_WAITING_STATUS_NOT_SUPPORTED
+                    || mQueryStatus == TelephonyManager.CALL_WAITING_STATUS_UNKNOWN_ERROR) {
+                Log.d(LOG_TAG, "handleGetCallWaitingResponse: Exception");
                 if (mTcpListener != null) {
                     mTcpListener.onError(CallWaitingSwitchPreference.this, RESPONSE_ERROR);
                 }
             } else {
-                if (DBG) {
-                    Log.d(LOG_TAG, "handleGetCallWaitingResponse: CW state successfully queried.");
-                }
-                int[] cwArray = (int[])ar.result;
-                // If cwArray[0] is = 1, then cwArray[1] must follow,
-                // with the TS 27.007 service class bit vector of services
-                // for which call waiting is enabled.
-                try {
-                    setChecked(((cwArray[0] == 1) && ((cwArray[1] & 0x01) == 0x01)));
-                } catch (ArrayIndexOutOfBoundsException e) {
-                    Log.e(LOG_TAG, "handleGetCallWaitingResponse: improper result: err ="
-                            + e.getMessage());
+                if (mQueryStatus == TelephonyManager.CALL_WAITING_STATUS_ENABLED) {
+                    setChecked(true);
+                } else {
+                    setChecked(false);
                 }
             }
-        }
-
-        private void handleSetCallWaitingResponse(Message msg) {
-            AsyncResult ar = (AsyncResult) msg.obj;
-
-            if (ar.exception != null) {
-                if (DBG) {
-                    Log.d(LOG_TAG, "handleSetCallWaitingResponse: ar.exception=" + ar.exception);
-                }
-                //setEnabled(false);
-            }
-            if (DBG) Log.d(LOG_TAG, "handleSetCallWaitingResponse: re get");
-
-            mPhone.getCallWaiting(obtainMessage(MESSAGE_GET_CALL_WAITING,
-                    MESSAGE_SET_CALL_WAITING, MESSAGE_SET_CALL_WAITING, ar.exception));
+            mIsDuringUpdateProcess = false;
         }
     }
 }
diff --git a/src/com/android/phone/CallWaitingUssdResultReceiver.java b/src/com/android/phone/CallWaitingUssdResultReceiver.java
new file mode 100644
index 0000000..b9049e9
--- /dev/null
+++ b/src/com/android/phone/CallWaitingUssdResultReceiver.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2021 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 com.android.phone;
+
+import static com.android.internal.util.Preconditions.checkNotNull;
+
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.RemoteException;
+import android.os.ResultReceiver;
+import android.telephony.TelephonyManager;
+import android.telephony.UssdResponse;
+import android.text.TextUtils;
+import android.util.Log;
+
+import com.android.internal.telephony.IIntegerConsumer;
+
+import java.util.HashMap;
+
+/**
+ * Handling the call waiting USSD result.
+ */
+public class CallWaitingUssdResultReceiver extends ResultReceiver {
+    private static final String LOG_TAG = "CwUssdResultReceiver";
+
+    private IIntegerConsumer mCallback;
+    private CarrierXmlParser mCarrierXmlParser;
+    private CarrierXmlParser.SsEntry.SSAction mSsAction;
+
+    CallWaitingUssdResultReceiver(Handler handler, IIntegerConsumer callback,
+            CarrierXmlParser carrierXmlParser, CarrierXmlParser.SsEntry.SSAction action) {
+        super(handler);
+        mCallback = callback;
+        mCarrierXmlParser = carrierXmlParser;
+        mSsAction = action;
+    }
+
+    @Override
+    protected void onReceiveResult(int resultCode, Bundle ussdResponse) {
+        log("USSD:" + resultCode);
+        checkNotNull(ussdResponse, "ussdResponse cannot be null.");
+        UssdResponse response = ussdResponse.getParcelable(
+                TelephonyManager.USSD_RESPONSE);
+
+        if (resultCode == TelephonyManager.USSD_RETURN_SUCCESS) {
+            int callWaitingStatus = getStatusFromResponse(response);
+            try {
+                mCallback.accept(callWaitingStatus);
+            } catch (RemoteException e) {
+                log("Fail to notify getCallWaitingStatus due to " + e);
+            }
+        } else {
+            try {
+                mCallback.accept(TelephonyManager.CALL_WAITING_STATUS_UNKNOWN_ERROR);
+            } catch (RemoteException e) {
+                log("Fail to notify getCallWaitingStatus due to " + e);
+            }
+        }
+    }
+
+    private int getStatusFromResponse(UssdResponse response) {
+        int callWaitingStatus = TelephonyManager.CALL_WAITING_STATUS_UNKNOWN_ERROR;
+
+        CarrierXmlParser.SsFeature callWaitingFeature = mCarrierXmlParser.getFeature(
+                CarrierXmlParser.FEATURE_CALL_WAITING);
+        if (callWaitingFeature == null) {
+            return callWaitingStatus;
+        }
+
+        HashMap<String, String> analysisResult = callWaitingFeature
+                .getResponseSet(mSsAction, response.getReturnMessage().toString());
+        if (analysisResult.get(CarrierXmlParser.TAG_RESPONSE_STATUS_ERROR) != null) {
+            return callWaitingStatus;
+        }
+
+        if (analysisResult != null && analysisResult.size() != 0) {
+            String tmpStatusStr = analysisResult.get(
+                    CarrierXmlParser.TAG_RESPONSE_STATUS);
+
+            if (!TextUtils.isEmpty(tmpStatusStr)) {
+                if (tmpStatusStr.equals(
+                        CarrierXmlParser.TAG_COMMAND_RESULT_DEFINITION_ACTIVATE)) {
+                    callWaitingStatus =
+                            TelephonyManager.CALL_WAITING_STATUS_ENABLED;
+                } else if (tmpStatusStr.equals(
+                        CarrierXmlParser.TAG_COMMAND_RESULT_DEFINITION_DEACTIVATE)) {
+                    callWaitingStatus =
+                            TelephonyManager.CALL_WAITING_STATUS_DISABLED;
+                }
+            }
+        }
+        return callWaitingStatus;
+    }
+
+    private static void log(String msg) {
+        Log.d(LOG_TAG, msg);
+    }
+}
diff --git a/src/com/android/phone/CarrierXmlParser.java b/src/com/android/phone/CarrierXmlParser.java
index 18602c9..6e01b43 100644
--- a/src/com/android/phone/CarrierXmlParser.java
+++ b/src/com/android/phone/CarrierXmlParser.java
@@ -67,6 +67,7 @@
 
     // To define feature's item name in xml
     public static final String FEATURE_CALL_FORWARDING = "callforwarding";
+    public static final String FEATURE_CALL_WAITING = "callwaiting";
     public static final String FEATURE_CALLER_ID = "callerid";
 
     // COMMAND_NAME is xml's command name.
diff --git a/src/com/android/phone/PhoneInterfaceManager.java b/src/com/android/phone/PhoneInterfaceManager.java
index 9a1e275..01db02d 100755
--- a/src/com/android/phone/PhoneInterfaceManager.java
+++ b/src/com/android/phone/PhoneInterfaceManager.java
@@ -209,6 +209,7 @@
 import java.util.NoSuchElementException;
 import java.util.Objects;
 import java.util.Set;
+import java.util.concurrent.Executors;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Consumer;
 
@@ -1152,7 +1153,6 @@
                     }
                     break;
                 }
-
                 case EVENT_PERFORM_NETWORK_SCAN_DONE:
                     ar = (AsyncResult) msg.obj;
                     request = (MainThreadRequest) ar.userObj;
@@ -5879,10 +5879,9 @@
      */
     @Override
     public void getCallWaitingStatus(int subId, IIntegerConsumer callback) {
-        enforceReadPrivilegedPermission("getCallForwarding");
+        enforceReadPrivilegedPermission("getCallWaitingStatus");
         long identity = Binder.clearCallingIdentity();
         try {
-
             Phone phone = getPhone(subId);
             if (phone == null) {
                 try {
@@ -5892,11 +5891,35 @@
                 }
                 return;
             }
-
-            Consumer<Integer> argument = FunctionalUtils.ignoreRemoteException(callback::accept);
+            CarrierConfigManager configManager = new CarrierConfigManager(phone.getContext());
+            PersistableBundle c = configManager.getConfigForSubId(subId);
+            boolean requireUssd = c.getBoolean(
+                    CarrierConfigManager.KEY_USE_CALL_WAITING_USSD_BOOL, false);
 
             if (DBG) log("getCallWaitingStatus: subId " + subId);
-            sendRequestAsync(CMD_GET_CALL_WAITING, argument, phone, null);
+            if (requireUssd) {
+                CarrierXmlParser carrierXmlParser = new CarrierXmlParser(phone.getContext(),
+                        getSubscriptionCarrierId(subId));
+                String newUssdCommand = "";
+                try {
+                    newUssdCommand = carrierXmlParser.getFeature(
+                            CarrierXmlParser.FEATURE_CALL_WAITING)
+                            .makeCommand(CarrierXmlParser.SsEntry.SSAction.QUERY, null);
+                } catch (NullPointerException e) {
+                    loge("Failed to generate USSD number" + e);
+                }
+                ResultReceiver wrappedCallback = new CallWaitingUssdResultReceiver(
+                        mMainThreadHandler, callback, carrierXmlParser,
+                        CarrierXmlParser.SsEntry.SSAction.QUERY);
+                final String ussdCommand = newUssdCommand;
+                Executors.newSingleThreadExecutor().execute(() -> {
+                    handleUssdRequest(subId, ussdCommand, wrappedCallback);
+                });
+            } else {
+                Consumer<Integer> argument = FunctionalUtils.ignoreRemoteException(
+                        callback::accept);
+                sendRequestAsync(CMD_GET_CALL_WAITING, argument, phone, null);
+            }
         } finally {
             Binder.restoreCallingIdentity(identity);
         }
@@ -5922,10 +5945,38 @@
                 return;
             }
 
-            Pair<Boolean, Consumer<Integer>> arguments = Pair.create(enable,
-                    FunctionalUtils.ignoreRemoteException(callback::accept));
+            CarrierConfigManager configManager = new CarrierConfigManager(phone.getContext());
+            PersistableBundle c = configManager.getConfigForSubId(subId);
+            boolean requireUssd = c.getBoolean(
+                    CarrierConfigManager.KEY_USE_CALL_WAITING_USSD_BOOL, false);
 
-            sendRequestAsync(CMD_SET_CALL_WAITING, arguments, phone, null);
+            if (DBG) log("getCallWaitingStatus: subId " + subId);
+            if (requireUssd) {
+                CarrierXmlParser carrierXmlParser = new CarrierXmlParser(phone.getContext(),
+                        getSubscriptionCarrierId(subId));
+                CarrierXmlParser.SsEntry.SSAction ssAction =
+                        enable ? CarrierXmlParser.SsEntry.SSAction.UPDATE_ACTIVATE
+                                : CarrierXmlParser.SsEntry.SSAction.UPDATE_DEACTIVATE;
+                String newUssdCommand = "";
+                try {
+                    newUssdCommand = carrierXmlParser.getFeature(
+                            CarrierXmlParser.FEATURE_CALL_WAITING)
+                            .makeCommand(ssAction, null);
+                } catch (NullPointerException e) {
+                    loge("Failed to generate USSD number" + e);
+                }
+                ResultReceiver wrappedCallback = new CallWaitingUssdResultReceiver(
+                        mMainThreadHandler, callback, carrierXmlParser, ssAction);
+                final String ussdCommand = newUssdCommand;
+                Executors.newSingleThreadExecutor().execute(() -> {
+                    handleUssdRequest(subId, ussdCommand, wrappedCallback);
+                });
+            } else {
+                Pair<Boolean, Consumer<Integer>> arguments = Pair.create(enable,
+                        FunctionalUtils.ignoreRemoteException(callback::accept));
+
+                sendRequestAsync(CMD_SET_CALL_WAITING, arguments, phone, null);
+            }
         } finally {
             Binder.restoreCallingIdentity(identity);
         }