Merge "Fix it will auto switch back to "No data transfer" after selecting "USB Tethering"" into sc-dev am: b4dccf9b8e

Original change: https://googleplex-android-review.googlesource.com/c/platform/packages/apps/Settings/+/15221930

Change-Id: I706d0ad598acd587e616903a9242c10c29078ab8

src/com/android/settings/connecteddevice/usb/UsbConnectionBroadcastReceiver.java

@@ -75,6 +75,9 @@ public class UsbConnectionBroadcastReceiver extends BroadcastReceiver implements
             if (intent.getExtras().getBoolean(UsbManager.USB_FUNCTION_ACCESSORY)) {
                 functions |= UsbManager.FUNCTION_ACCESSORY;
             }
+            if (intent.getExtras().getBoolean(UsbManager.USB_FUNCTION_NCM)) {
+                functions |= UsbManager.FUNCTION_NCM;
+            }
             mFunctions = functions;
             mDataRole = mUsbBackend.getDataRole();
             mPowerRole = mUsbBackend.getPowerRole();

src/com/android/settings/connecteddevice/usb/UsbDefaultFragment.java

@@ -74,8 +74,10 @@ public class UsbDefaultFragment extends RadioButtonPickerFragment {
                 Log.d(TAG, "UsbConnectionListener() connected : " + connected + ", functions : "
                         + functions + ", defaultFunctions : " + defaultFunctions
                         + ", mIsStartTethering : " + mIsStartTethering);
-                if (connected && !mIsConnected && defaultFunctions == UsbManager.FUNCTION_RNDIS
+                if (connected && !mIsConnected && (defaultFunctions == UsbManager.FUNCTION_RNDIS
+                        || defaultFunctions == UsbManager.FUNCTION_NCM)
                         && !mIsStartTethering) {
+                    mCurrentFunctions = defaultFunctions;
                     startTethering();
                 }
 
@@ -150,7 +152,11 @@ public class UsbDefaultFragment extends RadioButtonPickerFragment {
 
     @Override
     protected String getDefaultKey() {
-        return UsbBackend.usbFunctionsToString(mUsbBackend.getDefaultUsbFunctions());
+        long defaultUsbFunctions = mUsbBackend.getDefaultUsbFunctions();
+        // Because we didn't have an option for NCM, so make FUNCTION_NCM corresponding to
+        // FUNCTION_RNDIS for initializing the UI.
+        return UsbBackend.usbFunctionsToString(defaultUsbFunctions == UsbManager.FUNCTION_NCM
+                ? UsbManager.FUNCTION_RNDIS : defaultUsbFunctions);
     }
 
     @Override
@@ -158,9 +164,10 @@ public class UsbDefaultFragment extends RadioButtonPickerFragment {
         long functions = UsbBackend.usbFunctionsFromString(key);
         mPreviousFunctions = mUsbBackend.getCurrentFunctions();
         if (!Utils.isMonkeyRunning()) {
-            if (functions == UsbManager.FUNCTION_RNDIS) {
+            if (functions == UsbManager.FUNCTION_RNDIS || functions == UsbManager.FUNCTION_NCM) {
                 // We need to have entitlement check for usb tethering, so use API in
                 // TetheringManager.
+                mCurrentFunctions = functions;
                 startTethering();
             } else {
                 mIsStartTethering = false;
@@ -193,8 +200,7 @@ public class UsbDefaultFragment extends RadioButtonPickerFragment {
         public void onTetheringStarted() {
             Log.d(TAG, "onTetheringStarted()");
             // Set default usb functions again to make internal data persistent
-            mCurrentFunctions = UsbManager.FUNCTION_RNDIS;
+            mUsbBackend.setDefaultUsbFunctions(mCurrentFunctions);
-            mUsbBackend.setDefaultUsbFunctions(UsbManager.FUNCTION_RNDIS);
         }
 
         @Override
@@ -214,7 +220,11 @@ public class UsbDefaultFragment extends RadioButtonPickerFragment {
                 final boolean isSupported = mUsbBackend.areFunctionsSupported(option);
                 pref.setEnabled(isSupported);
                 if (isSupported) {
-                    pref.setChecked(functions == option);
+                    if (functions == UsbManager.FUNCTION_NCM) {
+                        pref.setChecked(UsbManager.FUNCTION_RNDIS == option);
+                    } else {
+                        pref.setChecked(functions == option);
+                    }
                 }
             }
         }

src/com/android/settings/connecteddevice/usb/UsbDetailsFunctionsController.java

@@ -116,6 +116,8 @@ public class UsbDetailsFunctionsController extends UsbDetailsController
             if (mUsbBackend.areFunctionsSupported(option)) {
                 if (isAccessoryMode(functions)) {
                     pref.setChecked(UsbManager.FUNCTION_MTP == option);
+                } else if (functions == UsbManager.FUNCTION_NCM) {
+                    pref.setChecked(UsbManager.FUNCTION_RNDIS == option);
                 } else {
                     pref.setChecked(functions == option);
                 }
@@ -148,7 +150,7 @@ public class UsbDetailsFunctionsController extends UsbDetailsController
                 preference.setChecked(true);
             }
 
-            if (function == UsbManager.FUNCTION_RNDIS) {
+            if (function == UsbManager.FUNCTION_RNDIS || function == UsbManager.FUNCTION_NCM) {
                 // We need to have entitlement check for usb tethering, so use API in
                 // TetheringManager.
                 mTetheringManager.startTethering(

tests/robotests/src/com/android/settings/connecteddevice/usb/UsbConnectionBroadcastReceiverTest.java

@@ -98,6 +98,20 @@ public class UsbConnectionBroadcastReceiverTest {
                 POWER_ROLE_NONE, DATA_ROLE_NONE);
     }
 
+    @Test
+    public void onReceive_usbConnectedNcmEnabled_invokesCallback() {
+        Intent intent = new Intent();
+        intent.setAction(UsbManager.ACTION_USB_STATE);
+        intent.putExtra(UsbManager.USB_CONNECTED, true);
+        intent.putExtra(UsbManager.USB_FUNCTION_NCM, true);
+        intent.putExtra(UsbManager.USB_DATA_UNLOCKED, true);
+
+        mReceiver.onReceive(mContext, intent);
+
+        verify(mListener).onUsbConnectionChanged(/* connected */ true, UsbManager.FUNCTION_NCM,
+                POWER_ROLE_NONE, DATA_ROLE_NONE);
+    }
+
     @Test
     public void onReceive_usbPortStatus_invokeCallback() {
         final Intent intent = new Intent();

tests/robotests/src/com/android/settings/connecteddevice/usb/UsbDefaultFragmentTest.java

@@ -103,6 +103,14 @@ public class UsbDefaultFragmentTest {
                 .isEqualTo(UsbBackend.usbFunctionsToString(UsbManager.FUNCTION_MIDI));
     }
 
+    @Test
+    public void getDefaultKey_isNcm_returnsRndis() {
+        when(mUsbBackend.getDefaultUsbFunctions()).thenReturn(UsbManager.FUNCTION_NCM);
+
+        assertThat(mFragment.getDefaultKey())
+                .isEqualTo(UsbBackend.usbFunctionsToString(UsbManager.FUNCTION_RNDIS));
+    }
+
     @Test
     public void setDefaultKey_isNone_shouldSetNone() {
         mFragment.setDefaultKey(UsbBackend.usbFunctionsToString(UsbManager.FUNCTION_NONE));
@@ -149,6 +157,19 @@ public class UsbDefaultFragmentTest {
                 UsbManager.FUNCTION_MTP);
     }
 
+    @Test
+    public void setDefaultKey_functionNcm_invokesStartTethering() {
+        doReturn(UsbManager.FUNCTION_MTP).when(mUsbBackend).getCurrentFunctions();
+
+        mFragment.setDefaultKey(UsbBackend.usbFunctionsToString(UsbManager.FUNCTION_NCM));
+
+        verify(mTetheringManager).startTethering(eq(TetheringManager.TETHERING_USB),
+                any(),
+                eq(mFragment.mOnStartTetheringCallback));
+        assertThat(mFragment.mPreviousFunctions).isEqualTo(
+                UsbManager.FUNCTION_MTP);
+    }
+
     @Test
     public void setDefaultKey_functionOther_setCurrentFunctionInvoked() {
         doReturn(UsbManager.FUNCTION_MTP).when(mUsbBackend).getCurrentFunctions();
@@ -161,14 +182,24 @@ public class UsbDefaultFragmentTest {
     }
 
     @Test
-    public void onTetheringStarted_setDefaultUsbFunctions() {
+    public void onTetheringStarted_currentFunctionsIsRndis_setsRndisAsDefaultUsbFunctions() {
-        mFragment.mPreviousFunctions = UsbManager.FUNCTION_PTP;
+        mFragment.mCurrentFunctions = UsbManager.FUNCTION_RNDIS;
 
         mFragment.mOnStartTetheringCallback.onTetheringStarted();
 
         verify(mUsbBackend).setDefaultUsbFunctions(UsbManager.FUNCTION_RNDIS);
     }
 
+    @Test
+    public void onTetheringStarted_currentFunctionsIsNcm_setsNcmAsDefaultUsbFunctions() {
+        mFragment.mCurrentFunctions = UsbManager.FUNCTION_NCM;
+
+        mFragment.mOnStartTetheringCallback.onTetheringStarted();
+
+        verify(mUsbBackend).setDefaultUsbFunctions(UsbManager.FUNCTION_NCM);
+    }
+
+
     @Test
     public void onPause_receivedRndis_shouldSetRndis() {
         mFragment.mIsStartTethering = true;
@@ -229,6 +260,18 @@ public class UsbDefaultFragmentTest {
         assertThat(mFragment.mCurrentFunctions).isEqualTo(UsbManager.FUNCTION_MIDI);
     }
 
+    @Test
+    public void onPause_receivedNcm_setsNcm() {
+        mFragment.mIsStartTethering = true;
+        mFragment.mUsbConnectionListener.onUsbConnectionChanged(/* connected */ true,
+                UsbManager.FUNCTION_NCM, POWER_ROLE_SINK, DATA_ROLE_DEVICE);
+
+        mFragment.onPause();
+
+        verify(mUsbBackend, times(2)).setDefaultUsbFunctions(UsbManager.FUNCTION_NCM);
+        assertThat(mFragment.mCurrentFunctions).isEqualTo(UsbManager.FUNCTION_NCM);
+    }
+
     @Test
     public void usbIsPluginAndUsbTetheringIsOn_startTetheringIsInvoked() {
         when(mUsbBackend.getDefaultUsbFunctions()).thenReturn(UsbManager.FUNCTION_RNDIS);
@@ -243,6 +286,20 @@ public class UsbDefaultFragmentTest {
                 eq(mFragment.mOnStartTetheringCallback));
     }
 
+    @Test
+    public void usbIsPluginAndUsbTetheringIsOn_receivedNcm_startsTethering() {
+        when(mUsbBackend.getDefaultUsbFunctions()).thenReturn(UsbManager.FUNCTION_NCM);
+
+        mFragment.mUsbConnectionListener.onUsbConnectionChanged(/* connected */ false,
+                UsbManager.FUNCTION_NCM, POWER_ROLE_SINK, DATA_ROLE_DEVICE);
+        mFragment.mUsbConnectionListener.onUsbConnectionChanged(/* connected */ true,
+                UsbManager.FUNCTION_NCM, POWER_ROLE_SINK, DATA_ROLE_DEVICE);
+
+        verify(mTetheringManager).startTethering(eq(TetheringManager.TETHERING_USB),
+                any(),
+                eq(mFragment.mOnStartTetheringCallback));
+    }
+
     @Test
     public void usbIsNotPluginAndUsbTetheringIsOn_startTetheringIsNotInvoked() {
         when(mUsbBackend.getDefaultUsbFunctions()).thenReturn(UsbManager.FUNCTION_RNDIS);

tests/robotests/src/com/android/settings/connecteddevice/usb/UsbDetailsFunctionsControllerTest.java

@@ -167,6 +167,19 @@ public class UsbDetailsFunctionsControllerTest {
         assertThat(prefs.get(0).isChecked()).isTrue();
     }
 
+    @Test
+    public void displayRefresh_ncmEnabled_checksSwitches() {
+        when(mUsbBackend.areFunctionsSupported(anyLong())).thenReturn(true);
+
+        mDetailsFunctionsController.refresh(true, UsbManager.FUNCTION_NCM, POWER_ROLE_SINK,
+                DATA_ROLE_DEVICE);
+        List<RadioButtonPreference> prefs = getRadioPreferences();
+
+        assertThat(prefs.get(1).getKey())
+                .isEqualTo(UsbBackend.usbFunctionsToString(UsbManager.FUNCTION_RNDIS));
+        assertThat(prefs.get(1).isChecked()).isTrue();
+    }
+
     @Test
     public void onClickMtp_noneEnabled_shouldEnableMtp() {
         when(mUsbBackend.areFunctionsSupported(anyLong())).thenReturn(true);
@@ -253,6 +266,20 @@ public class UsbDetailsFunctionsControllerTest {
                 UsbManager.FUNCTION_MTP);
     }
 
+    @Test
+    public void onRadioButtonClicked_functionNcm_startsTethering() {
+        mRadioButtonPreference.setKey(UsbBackend.usbFunctionsToString(UsbManager.FUNCTION_NCM));
+        doReturn(UsbManager.FUNCTION_MTP).when(mUsbBackend).getCurrentFunctions();
+
+        mDetailsFunctionsController.onRadioButtonClicked(mRadioButtonPreference);
+
+        verify(mTetheringManager).startTethering(eq(TetheringManager.TETHERING_USB),
+                any(),
+                eq(mDetailsFunctionsController.mOnStartTetheringCallback));
+        assertThat(mDetailsFunctionsController.mPreviousFunction).isEqualTo(
+                UsbManager.FUNCTION_MTP);
+    }
+
     @Test
     public void onRadioButtonClicked_functionOther_setCurrentFunctionInvoked() {
         mRadioButtonPreference.setKey(UsbBackend.usbFunctionsToString(UsbManager.FUNCTION_PTP));