diff --git a/flags/data.aconfig b/flags/data.aconfig
index cad7da7..3beb016 100644
--- a/flags/data.aconfig
+++ b/flags/data.aconfig
@@ -111,3 +111,10 @@
   description: "When QNS prefers MMS on IWLAN, MMS will be attempted on IWLAN if it can, even though if existing cellular network already supports MMS."
   bug: "316211526"
 }
+
+flag {
+  name: "reconnect_qualified_network"
+  namespace: "telephony"
+  description: "This flag is for internal implementation to handle reconnect request from QNS in telephony FWK."
+  bug: "319520561"
+}
\ No newline at end of file
diff --git a/src/java/com/android/internal/telephony/ServiceStateTracker.java b/src/java/com/android/internal/telephony/ServiceStateTracker.java
index 88d541c..ba6479e 100644
--- a/src/java/com/android/internal/telephony/ServiceStateTracker.java
+++ b/src/java/com/android/internal/telephony/ServiceStateTracker.java
@@ -739,7 +739,7 @@
 
         mAccessNetworksManagerCallback = new AccessNetworksManagerCallback(this::post) {
             @Override
-            public void onPreferredTransportChanged(int networkCapability) {
+            public void onPreferredTransportChanged(int networkCapability, boolean forceReconnect) {
                 // Check if preferred on IWLAN was changed in ServiceState.
                 boolean isIwlanPreferred = mAccessNetworksManager.isAnyApnOnIwlan();
                 if (mSS.isIwlanPreferred() != isIwlanPreferred) {
diff --git a/src/java/com/android/internal/telephony/data/AccessNetworksManager.java b/src/java/com/android/internal/telephony/data/AccessNetworksManager.java
index a657ecd..3d3fbe9 100644
--- a/src/java/com/android/internal/telephony/data/AccessNetworksManager.java
+++ b/src/java/com/android/internal/telephony/data/AccessNetworksManager.java
@@ -234,6 +234,11 @@
                     .mapToObj(AccessNetworkType::toString).collect(Collectors.joining(","))
                     + "]");
 
+            handleQualifiedNetworksChanged(apnTypes, qualifiedNetworkTypes, false);
+        }
+
+        private void handleQualifiedNetworksChanged(
+                int apnTypes, int[] qualifiedNetworkTypes, boolean forceReconnect) {
             if (Arrays.stream(qualifiedNetworkTypes).anyMatch(accessNetwork
                     -> !DataUtils.isValidAccessNetwork(accessNetwork))) {
                 loge("Invalid access networks " + Arrays.toString(qualifiedNetworkTypes));
@@ -274,8 +279,9 @@
                                     AccessNetworkConstants.TRANSPORT_TYPE_WWAN);
                             mAccessNetworksManagerCallbacks.forEach(callback ->
                                     callback.invokeFromExecutor(() ->
-                                            callback.onPreferredTransportChanged(DataUtils
-                                                    .apnTypeToNetworkCapability(apnType))));
+                                            callback.onPreferredTransportChanged(
+                                                    DataUtils.apnTypeToNetworkCapability(apnType),
+                                                    forceReconnect)));
                         }
                     } else {
                         mAvailableNetworks.put(apnType, qualifiedNetworkTypes);
@@ -297,7 +303,7 @@
             }
 
             if (!qualifiedNetworksList.isEmpty()) {
-                setPreferredTransports(qualifiedNetworksList);
+                setPreferredTransports(qualifiedNetworksList, forceReconnect);
                 mQualifiedNetworksChangedRegistrants.notifyResult(qualifiedNetworksList);
             }
         }
@@ -338,6 +344,17 @@
                 }
             });
         }
+
+        @Override
+        public void onReconnectQualifedNetworkType(int apnTypes, int qualifiedNetworkType) {
+            if (mFeatureFlags.reconnectQualifiedNetwork()) {
+                log("onReconnectQualifedNetworkType: apnTypes = ["
+                        + ApnSetting.getApnTypesStringFromBitmask(apnTypes)
+                        + "], networks = [" + AccessNetworkType.toString(qualifiedNetworkType)
+                        + "]");
+                handleQualifiedNetworksChanged(apnTypes, new int[]{qualifiedNetworkType}, true);
+            }
+        }
     }
 
     private void onEmergencyDataNetworkPreferredTransportChanged(
@@ -371,8 +388,10 @@
          * Called when preferred transport changed.
          *
          * @param networkCapability The network capability.
+         * @param forceReconnect whether enforce reconnection to the preferred transport type.
          */
-        public abstract void onPreferredTransportChanged(@NetCapability int networkCapability);
+        public abstract void onPreferredTransportChanged(
+                @NetCapability int networkCapability, boolean forceReconnect);
     }
 
     /**
@@ -610,7 +629,8 @@
                 : AccessNetworkConstants.TRANSPORT_TYPE_WWAN;
     }
 
-    private void setPreferredTransports(@NonNull List<QualifiedNetworks> networksList) {
+    private void setPreferredTransports(
+            @NonNull List<QualifiedNetworks> networksList, boolean forceReconnect) {
         for (QualifiedNetworks networks : networksList) {
             if (networks.qualifiedNetworks.length > 0) {
                 int transport = getTransportFromAccessNetwork(networks.qualifiedNetworks[0]);
@@ -618,11 +638,13 @@
                     mPreferredTransports.put(networks.apnType, transport);
                     mAccessNetworksManagerCallbacks.forEach(callback ->
                             callback.invokeFromExecutor(() ->
-                                    callback.onPreferredTransportChanged(DataUtils
-                                            .apnTypeToNetworkCapability(networks.apnType))));
+                                    callback.onPreferredTransportChanged(
+                                            DataUtils.apnTypeToNetworkCapability(networks.apnType),
+                                            forceReconnect)));
                     logl("setPreferredTransports: apnType="
                             + ApnSetting.getApnTypeString(networks.apnType) + ", transport="
-                            + AccessNetworkConstants.transportTypeToString(transport));
+                            + AccessNetworkConstants.transportTypeToString(transport)
+                            + (forceReconnect ? ", forceReconnect:true" : ""));
                 }
             }
         }
@@ -643,7 +665,7 @@
      * Get the  preferred transport by network capability.
      *
      * @param networkCapability The network capability. (Note that only APN-type capabilities are
-     * supported.
+     * supported.)
      * @return The preferred transport.
      */
     public @TransportType int getPreferredTransportByNetworkCapability(
@@ -662,7 +684,7 @@
      * @return {@code true} if there is any APN is on IWLAN, otherwise {@code false}.
      */
     public boolean isAnyApnOnIwlan() {
-        for (int apnType : AccessNetworksManager.SUPPORTED_APN_TYPES) {
+        for (int apnType : SUPPORTED_APN_TYPES) {
             if (getPreferredTransport(apnType) == AccessNetworkConstants.TRANSPORT_TYPE_WLAN) {
                 return true;
             }
diff --git a/src/java/com/android/internal/telephony/data/DataNetwork.java b/src/java/com/android/internal/telephony/data/DataNetwork.java
index d52a3b4..6ae861c 100644
--- a/src/java/com/android/internal/telephony/data/DataNetwork.java
+++ b/src/java/com/android/internal/telephony/data/DataNetwork.java
@@ -1185,7 +1185,7 @@
                             getHandler()::post) {
                         @Override
                         public void onPreferredTransportChanged(
-                                @NetCapability int networkCapability) {
+                                @NetCapability int networkCapability, boolean forceReconnect) {
                             if (networkCapability == NetworkCapabilities.NET_CAPABILITY_MMS) {
                                 log("MMS preference changed.");
                                 updateNetworkCapabilities();
diff --git a/src/java/com/android/internal/telephony/data/DataNetworkController.java b/src/java/com/android/internal/telephony/data/DataNetworkController.java
index d16387f..645e8bd 100644
--- a/src/java/com/android/internal/telephony/data/DataNetworkController.java
+++ b/src/java/com/android/internal/telephony/data/DataNetworkController.java
@@ -952,13 +952,16 @@
 
         mAccessNetworksManager.registerCallback(new AccessNetworksManagerCallback(this::post) {
             @Override
-            public void onPreferredTransportChanged(@NetCapability int capability) {
+            public void onPreferredTransportChanged(
+                    @NetCapability int capability, boolean forceReconnect) {
                 int preferredTransport = mAccessNetworksManager
                         .getPreferredTransportByNetworkCapability(capability);
                 logl("onPreferredTransportChanged: "
                         + DataUtils.networkCapabilityToString(capability) + " preferred on "
-                        + AccessNetworkConstants.transportTypeToString(preferredTransport));
-                DataNetworkController.this.onEvaluatePreferredTransport(capability);
+                        + AccessNetworkConstants.transportTypeToString(preferredTransport)
+                        + (forceReconnect ? "forceReconnect:true" : ""));
+
+                DataNetworkController.this.onEvaluatePreferredTransport(capability, forceReconnect);
                 if (!hasMessages(EVENT_REEVALUATE_UNSATISFIED_NETWORK_REQUESTS)) {
                     sendMessage(obtainMessage(EVENT_REEVALUATE_UNSATISFIED_NETWORK_REQUESTS,
                             DataEvaluationReason.PREFERRED_TRANSPORT_CHANGED));
@@ -1142,7 +1145,7 @@
                 }
                 break;
             case EVENT_EVALUATE_PREFERRED_TRANSPORT:
-                onEvaluatePreferredTransport(msg.arg1);
+                onEvaluatePreferredTransport(msg.arg1, msg.arg2 != 0 /* forceReconnect */);
                 break;
             case EVENT_SUBSCRIPTION_PLANS_CHANGED:
                 SubscriptionPlan[] plans = (SubscriptionPlan[]) msg.obj;
@@ -3223,8 +3226,12 @@
      * Called when needed to evaluate the preferred transport for certain capability.
      *
      * @param capability The network capability to evaluate.
+     * @param forceReconnect indicates whether enforce reconnection to move to the preferred
+     *                       transport type.
+     *
      */
-    private void onEvaluatePreferredTransport(@NetCapability int capability) {
+    private void onEvaluatePreferredTransport(
+            @NetCapability int capability, boolean forceReconnect) {
         int preferredTransport = mAccessNetworksManager
                 .getPreferredTransportByNetworkCapability(capability);
         log("onEvaluatePreferredTransport: " + DataUtils.networkCapabilityToString(capability)
@@ -3248,7 +3255,13 @@
                     continue;
                 }
 
-                tryHandoverDataNetwork(dataNetwork, preferredTransport, null/*handoverRetryEntry*/);
+                if (forceReconnect) {
+                    tearDownGracefully(
+                            dataNetwork, DataNetwork.TEAR_DOWN_REASON_HANDOVER_NOT_ALLOWED);
+                } else {
+                    tryHandoverDataNetwork(
+                            dataNetwork, preferredTransport, null/*handoverRetryEntry*/);
+                }
             }
         }
     }
diff --git a/src/java/com/android/internal/telephony/domainselection/EmergencyCallDomainSelectionConnection.java b/src/java/com/android/internal/telephony/domainselection/EmergencyCallDomainSelectionConnection.java
index b64c7cb..af4b03a 100644
--- a/src/java/com/android/internal/telephony/domainselection/EmergencyCallDomainSelectionConnection.java
+++ b/src/java/com/android/internal/telephony/domainselection/EmergencyCallDomainSelectionConnection.java
@@ -160,7 +160,8 @@
     private AccessNetworksManager.AccessNetworksManagerCallback mPreferredTransportCallback =
             new AccessNetworksManager.AccessNetworksManagerCallback(Runnable::run) {
         @Override
-        public void onPreferredTransportChanged(@NetCapability int capability) {
+        public void onPreferredTransportChanged(
+                @NetCapability int capability, boolean forceReconnect) {
         }
     };
 
diff --git a/tests/telephonytests/src/com/android/internal/telephony/ServiceStateTrackerTest.java b/tests/telephonytests/src/com/android/internal/telephony/ServiceStateTrackerTest.java
index 1a6557b..121136d 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/ServiceStateTrackerTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/ServiceStateTrackerTest.java
@@ -3373,7 +3373,7 @@
         assertFalse(sst.mSS.isIwlanPreferred());
 
         when(mAccessNetworksManager.isAnyApnOnIwlan()).thenReturn(true);
-        accessNetworksManagerCallback.onPreferredTransportChanged(0);
+        accessNetworksManagerCallback.onPreferredTransportChanged(0, false);
         waitForLastHandlerAction(mSSTTestHandler.getThreadHandler());
 
         assertTrue(sst.mSS.isIwlanPreferred());
diff --git a/tests/telephonytests/src/com/android/internal/telephony/data/AccessNetworksManagerTest.java b/tests/telephonytests/src/com/android/internal/telephony/data/AccessNetworksManagerTest.java
index 91ed03f..d1e5066 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/data/AccessNetworksManagerTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/data/AccessNetworksManagerTest.java
@@ -279,9 +279,9 @@
         processAllMessages();
 
         verify(mMockedCallback).onPreferredTransportChanged(
-                eq(NetworkCapabilities.NET_CAPABILITY_MMS));
+                eq(NetworkCapabilities.NET_CAPABILITY_MMS), eq(false));
         verify(mMockedCallback).onPreferredTransportChanged(
-                eq(NetworkCapabilities.NET_CAPABILITY_IMS));
+                eq(NetworkCapabilities.NET_CAPABILITY_IMS), eq(false));
         Mockito.clearInvocations(mMockedCallback);
         assertThat(mAccessNetworksManager.getPreferredTransportByNetworkCapability(
                 NetworkCapabilities.NET_CAPABILITY_MMS)).isEqualTo(
@@ -295,7 +295,7 @@
         processAllMessages();
 
         verify(mMockedCallback).onPreferredTransportChanged(
-                eq(NetworkCapabilities.NET_CAPABILITY_XCAP));
+                eq(NetworkCapabilities.NET_CAPABILITY_XCAP), eq(false));
         Mockito.clearInvocations(mMockedCallback);
         assertThat(mAccessNetworksManager.getPreferredTransportByNetworkCapability(
                 NetworkCapabilities.NET_CAPABILITY_XCAP)).isEqualTo(
@@ -305,11 +305,12 @@
                 ApnSetting.TYPE_XCAP | ApnSetting.TYPE_IMS | ApnSetting.TYPE_MMS,
                 new int[]{});
         verify(mMockedCallback).onPreferredTransportChanged(
-                eq(NetworkCapabilities.NET_CAPABILITY_IMS));
+                eq(NetworkCapabilities.NET_CAPABILITY_IMS), eq(false));
         verify(mMockedCallback).onPreferredTransportChanged(
-                eq(NetworkCapabilities.NET_CAPABILITY_MMS));
+                eq(NetworkCapabilities.NET_CAPABILITY_MMS), eq(false));
         verify(mMockedCallback).onPreferredTransportChanged(
-                eq(NetworkCapabilities.NET_CAPABILITY_XCAP));
+                eq(NetworkCapabilities.NET_CAPABILITY_XCAP), eq(false));
+        Mockito.clearInvocations(mMockedCallback);
         assertThat(mAccessNetworksManager.getPreferredTransportByNetworkCapability(
                 NetworkCapabilities.NET_CAPABILITY_IMS)).isEqualTo(
                 AccessNetworkConstants.TRANSPORT_TYPE_WWAN);
@@ -348,4 +349,57 @@
                 mIntegerConsumer);
     }
 
+    @Test
+    public void testCallbackForReconnectQualifiedNetworkTypeWithFlagEnabled()  throws Exception {
+        when(mFeatureFlags.reconnectQualifiedNetwork()).thenReturn(true);
+
+
+        mAccessNetworksManager.registerCallback(mMockedCallback);
+
+        mQnsCallback.onReconnectQualifedNetworkType(ApnSetting.TYPE_IMS | ApnSetting.TYPE_MMS,
+                AccessNetworkType.IWLAN);
+        processAllMessages();
+
+        verify(mMockedCallback).onPreferredTransportChanged(
+                eq(NetworkCapabilities.NET_CAPABILITY_MMS), eq(true));
+        verify(mMockedCallback).onPreferredTransportChanged(
+                eq(NetworkCapabilities.NET_CAPABILITY_IMS), eq(true));
+        verify(mMockedCallback, never()).onPreferredTransportChanged(
+                eq(NetworkCapabilities.NET_CAPABILITY_XCAP), eq(true));
+        Mockito.clearInvocations(mMockedCallback);
+        assertThat(mAccessNetworksManager.getPreferredTransportByNetworkCapability(
+                NetworkCapabilities.NET_CAPABILITY_MMS)).isEqualTo(
+                AccessNetworkConstants.TRANSPORT_TYPE_WLAN);
+        assertThat(mAccessNetworksManager.getPreferredTransportByNetworkCapability(
+                NetworkCapabilities.NET_CAPABILITY_IMS)).isEqualTo(
+                AccessNetworkConstants.TRANSPORT_TYPE_WLAN);
+        assertThat(mAccessNetworksManager.getPreferredTransportByNetworkCapability(
+                NetworkCapabilities.NET_CAPABILITY_XCAP)).isEqualTo(
+                AccessNetworkConstants.TRANSPORT_TYPE_WWAN);
+    }
+
+    @Test
+    public void testCallbackForReconnectQualifiedNetworkTypeWithFlagDisabled() throws Exception {
+        when(mFeatureFlags.reconnectQualifiedNetwork()).thenReturn(false);
+        mQnsCallback.onReconnectQualifedNetworkType(ApnSetting.TYPE_IMS | ApnSetting.TYPE_MMS,
+                AccessNetworkType.IWLAN);
+        processAllMessages();
+
+        verify(mMockedCallback, never()).onPreferredTransportChanged(
+                eq(NetworkCapabilities.NET_CAPABILITY_MMS), eq(true));
+        verify(mMockedCallback, never()).onPreferredTransportChanged(
+                eq(NetworkCapabilities.NET_CAPABILITY_IMS), eq(true));
+        verify(mMockedCallback, never()).onPreferredTransportChanged(
+                eq(NetworkCapabilities.NET_CAPABILITY_XCAP), eq(true));
+        Mockito.clearInvocations(mMockedCallback);
+        assertThat(mAccessNetworksManager.getPreferredTransportByNetworkCapability(
+                NetworkCapabilities.NET_CAPABILITY_MMS)).isEqualTo(
+                AccessNetworkConstants.TRANSPORT_TYPE_WWAN);
+        assertThat(mAccessNetworksManager.getPreferredTransportByNetworkCapability(
+                NetworkCapabilities.NET_CAPABILITY_IMS)).isEqualTo(
+                AccessNetworkConstants.TRANSPORT_TYPE_WWAN);
+        assertThat(mAccessNetworksManager.getPreferredTransportByNetworkCapability(
+                NetworkCapabilities.NET_CAPABILITY_XCAP)).isEqualTo(
+                AccessNetworkConstants.TRANSPORT_TYPE_WWAN);
+    }
 }
diff --git a/tests/telephonytests/src/com/android/internal/telephony/data/DataNetworkControllerTest.java b/tests/telephonytests/src/com/android/internal/telephony/data/DataNetworkControllerTest.java
index fa4f8e4..14bad95 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/data/DataNetworkControllerTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/data/DataNetworkControllerTest.java
@@ -731,7 +731,14 @@
     private void updateTransport(@NetCapability int capability, @TransportType int transport) {
         doReturn(transport).when(mAccessNetworksManager)
                 .getPreferredTransportByNetworkCapability(capability);
-        mAccessNetworksManagerCallback.onPreferredTransportChanged(capability);
+        mAccessNetworksManagerCallback.onPreferredTransportChanged(capability, false);
+        processAllMessages();
+    }
+
+    private void reconnectTransport(@NetCapability int capability, @TransportType int transport) {
+        doReturn(transport).when(mAccessNetworksManager)
+                .getPreferredTransportByNetworkCapability(capability);
+        mAccessNetworksManagerCallback.onPreferredTransportChanged(capability, true);
         processAllMessages();
     }
 
@@ -2881,7 +2888,7 @@
         doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WLAN).when(mAccessNetworksManager)
                 .getPreferredTransportByNetworkCapability(NetworkCapabilities.NET_CAPABILITY_IMS);
         mAccessNetworksManagerCallback.onPreferredTransportChanged(
-                NetworkCapabilities.NET_CAPABILITY_IMS);
+                NetworkCapabilities.NET_CAPABILITY_IMS, false);
         serviceStateChanged(TelephonyManager.NETWORK_TYPE_UMTS,
                 NetworkRegistrationInfo.REGISTRATION_STATE_HOME);
         processAllMessages();
@@ -4975,4 +4982,73 @@
         assertThat(waitForIntegerConsumerResponse(1 /*numOfEvents*/)).isTrue();
         assertThat(mIntegerConsumerResult).isEqualTo(DataServiceCallback.RESULT_ERROR_INVALID_ARG);
     }
+
+    @Test
+    public void testForceReconnectToPreferredTransportType() throws Exception {
+        testSetupImsDataNetwork();
+        reconnectTransport(NetworkCapabilities.NET_CAPABILITY_IMS,
+                AccessNetworkConstants.TRANSPORT_TYPE_WLAN);
+
+        // Verify IMS network was torn down on source first.
+        verify(mMockedWwanDataServiceManager).deactivateDataCall(anyInt(),
+                eq(DataService.REQUEST_REASON_NORMAL), any(Message.class));
+
+        // Verify that IWLAN is brought up again on IWLAN.
+        verify(mMockedWlanDataServiceManager).setupDataCall(anyInt(),
+                any(DataProfile.class), anyBoolean(), anyBoolean(),
+                eq(DataService.REQUEST_REASON_NORMAL), any(), anyInt(), any(), any(), anyBoolean(),
+                any(Message.class));
+
+        DataNetwork dataNetwork = getDataNetworks().get(0);
+        assertThat(dataNetwork.getTransport()).isEqualTo(
+                AccessNetworkConstants.TRANSPORT_TYPE_WLAN);
+    }
+
+    @Test
+    public void testForceReconnectIgnored() throws Exception {
+        mCarrierConfig.putStringArray(
+                CarrierConfigManager.KEY_IWLAN_HANDOVER_POLICY_STRING_ARRAY,
+                new String[]{
+                        "source=EUTRAN|NGRAN|IWLAN|UNKNOWN, target=EUTRAN|NGRAN|IWLAN, "
+                                + "type=allowed, capabilities=IMS"
+                });
+        carrierConfigChanged();
+
+        testSetupImsDataNetwork();
+        reconnectTransport(NetworkCapabilities.NET_CAPABILITY_IMS,
+                AccessNetworkConstants.TRANSPORT_TYPE_WWAN);
+
+        // request reconnection to current transport type, tear down should not happen.
+        verify(mMockedWwanDataServiceManager, never()).deactivateDataCall(anyInt(),
+                eq(DataService.REQUEST_REASON_NORMAL), any(Message.class));
+
+        Mockito.reset(mMockedWlanDataServiceManager);
+
+        // Trigger Handover to IWLAN.
+        updateTransport(NetworkCapabilities.NET_CAPABILITY_IMS,
+                AccessNetworkConstants.TRANSPORT_TYPE_WLAN);
+
+        // Capture the message for setup data call response. We want to delay it.
+        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
+        verify(mMockedWlanDataServiceManager).setupDataCall(anyInt(), any(DataProfile.class),
+                anyBoolean(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), anyBoolean(),
+                messageCaptor.capture());
+
+        // Force reconnect to preferred transport type while handover is in progress.
+        reconnectTransport(NetworkCapabilities.NET_CAPABILITY_IMS,
+                AccessNetworkConstants.TRANSPORT_TYPE_WWAN);
+
+        // Finally handover is completed.
+        Message msg = messageCaptor.getValue();
+        DataCallResponse response = new DataCallResponse.Builder()
+                .setCause(DataFailCause.NONE)
+                .build();
+        msg.getData().putParcelable("data_call_response", response);
+        msg.arg1 = DataServiceCallback.RESULT_SUCCESS;
+        msg.sendToTarget();
+        processAllMessages();
+
+        verify(mMockedWwanDataServiceManager, never()).deactivateDataCall(anyInt(),
+                eq(DataService.REQUEST_REASON_NORMAL), any(Message.class));
+    }
 }
diff --git a/tests/telephonytests/src/com/android/internal/telephony/data/DataNetworkTest.java b/tests/telephonytests/src/com/android/internal/telephony/data/DataNetworkTest.java
index ad1ba61..66444da 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/data/DataNetworkTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/data/DataNetworkTest.java
@@ -2242,7 +2242,7 @@
                 any(TelephonyNetworkRequest.class),
                     eq(TelephonyManager.NETWORK_TYPE_IWLAN), eq(false), eq(false), eq(false));
         accessNetworksManagerCallbackArgumentCaptor.getValue()
-                .onPreferredTransportChanged(NetworkCapabilities.NET_CAPABILITY_MMS);
+                .onPreferredTransportChanged(NetworkCapabilities.NET_CAPABILITY_MMS, false);
         processAllMessages();
 
         // Check if MMS capability is removed.
@@ -2253,7 +2253,7 @@
         doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WWAN).when(mAccessNetworksManager)
             .getPreferredTransportByNetworkCapability(NetworkCapabilities.NET_CAPABILITY_MMS);
         accessNetworksManagerCallbackArgumentCaptor.getValue()
-                .onPreferredTransportChanged(NetworkCapabilities.NET_CAPABILITY_MMS);
+                .onPreferredTransportChanged(NetworkCapabilities.NET_CAPABILITY_MMS, false);
         processAllMessages();
 
         // Check if MMS capability is added back.