Revert "resolve merge conflicts of 7849607a7c to pi-dev-plus-aosp"

This reverts commit e81224d80c.

Reason for revert: broke pi-dev-plus-aosp

Change-Id: Ib45b96216017d01b6301a558a0cd27bf1071779c
Merged-In: I3d2ebad2879479a870bcdfe596bb88b83c424389

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

@@ -16,14 +16,9 @@
 
 package com.android.settings.connecteddevice.usb;
 
-import static android.net.ConnectivityManager.TETHERING_USB;
-
 import android.content.Context;
 import android.graphics.drawable.Drawable;
-import android.hardware.usb.UsbManager;
-import android.net.ConnectivityManager;
 import android.os.Bundle;
-import android.util.Log;
 
 import com.android.internal.annotations.VisibleForTesting;
 import com.android.internal.logging.nano.MetricsProto;
@@ -44,18 +39,11 @@ import java.util.List;
 public class UsbDefaultFragment extends RadioButtonPickerFragment {
     @VisibleForTesting
     UsbBackend mUsbBackend;
-    @VisibleForTesting
-    ConnectivityManager mConnectivityManager;
-    @VisibleForTesting
-    OnStartTetheringCallback mOnStartTetheringCallback = new OnStartTetheringCallback();
-    @VisibleForTesting
-    long mPreviousFunctions;
 
     @Override
     public void onAttach(Context context) {
         super.onAttach(context);
         mUsbBackend = new UsbBackend(context);
-        mConnectivityManager = context.getSystemService(ConnectivityManager.class);
     }
 
     @Override
@@ -115,37 +103,9 @@ public class UsbDefaultFragment extends RadioButtonPickerFragment {
     @Override
     protected boolean setDefaultKey(String key) {
         long functions = UsbBackend.usbFunctionsFromString(key);
-        mPreviousFunctions = mUsbBackend.getCurrentFunctions();
         if (!Utils.isMonkeyRunning()) {
-            if (functions == UsbManager.FUNCTION_RNDIS) {
-                // We need to have entitlement check for usb tethering, so use API in
-                // ConnectivityManager.
-                mConnectivityManager.startTethering(TETHERING_USB, true /* showProvisioningUi */,
-                        mOnStartTetheringCallback);
-            } else {
             mUsbBackend.setDefaultUsbFunctions(functions);
         }
-
-        }
         return true;
     }
-
-    @VisibleForTesting
-    final class OnStartTetheringCallback extends
-            ConnectivityManager.OnStartTetheringCallback {
-
-        @Override
-        public void onTetheringStarted() {
-            super.onTetheringStarted();
-            // Set default usb functions again to make internal data persistent
-            mUsbBackend.setDefaultUsbFunctions(UsbManager.FUNCTION_RNDIS);
-        }
-
-        @Override
-        public void onTetheringFailed() {
-            super.onTetheringFailed();
-            mUsbBackend.setDefaultUsbFunctions(mPreviousFunctions);
-            updateCandidates();
-        }
-    }
 }

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

@@ -16,14 +16,9 @@
 
 package com.android.settings.connecteddevice.usb;
 
-import static android.net.ConnectivityManager.TETHERING_USB;
-
 import android.content.Context;
 import android.hardware.usb.UsbManager;
 import android.hardware.usb.UsbPort;
-import android.net.ConnectivityManager;
-
-import androidx.annotation.VisibleForTesting;
 import androidx.preference.PreferenceCategory;
 import androidx.preference.PreferenceScreen;
 
@@ -51,18 +46,10 @@ public class UsbDetailsFunctionsController extends UsbDetailsController
     }
 
     private PreferenceCategory mProfilesContainer;
-    private ConnectivityManager mConnectivityManager;
-    @VisibleForTesting
-    OnStartTetheringCallback mOnStartTetheringCallback;
-    @VisibleForTesting
-    long mPreviousFunction;
 
     public UsbDetailsFunctionsController(Context context, UsbDetailsFragment fragment,
             UsbBackend backend) {
         super(context, fragment, backend);
-        mConnectivityManager = context.getSystemService(ConnectivityManager.class);
-        mOnStartTetheringCallback = new OnStartTetheringCallback();
-        mPreviousFunction = mUsbBackend.getCurrentFunctions();
     }
 
     @Override
@@ -109,30 +96,11 @@ public class UsbDetailsFunctionsController extends UsbDetailsController
 
     @Override
     public void onRadioButtonClicked(RadioButtonPreference preference) {
-        final long function = UsbBackend.usbFunctionsFromString(preference.getKey());
+        long function = UsbBackend.usbFunctionsFromString(preference.getKey());
-        final long previousFunction = mUsbBackend.getCurrentFunctions();
+        if (function != mUsbBackend.getCurrentFunctions() && !Utils.isMonkeyRunning()) {
-        if (function != previousFunction && !Utils.isMonkeyRunning()) {
-            mPreviousFunction = previousFunction;
-
-            if (function == UsbManager.FUNCTION_RNDIS) {
-                //Update the UI in advance to make it looks smooth
-                final RadioButtonPreference prevPref =
-                        (RadioButtonPreference) mProfilesContainer.findPreference(
-                                UsbBackend.usbFunctionsToString(mPreviousFunction));
-                if (prevPref != null) {
-                    prevPref.setChecked(false);
-                    preference.setChecked(true);
-                }
-
-                // We need to have entitlement check for usb tethering, so use API in
-                // ConnectivityManager.
-                mConnectivityManager.startTethering(TETHERING_USB, true /* showProvisioningUi */,
-                        mOnStartTetheringCallback);
-            } else {
             mUsbBackend.setCurrentFunctions(function);
         }
     }
-    }
 
     @Override
     public boolean isAvailable() {
@@ -143,15 +111,4 @@ public class UsbDetailsFunctionsController extends UsbDetailsController
     public String getPreferenceKey() {
         return "usb_details_functions";
     }
-
-    @VisibleForTesting
-    final class OnStartTetheringCallback extends
-            ConnectivityManager.OnStartTetheringCallback {
-
-        @Override
-        public void onTetheringFailed() {
-            super.onTetheringFailed();
-            mUsbBackend.setCurrentFunctions(mPreviousFunction);
-        }
-    }
 }

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

@@ -16,21 +16,12 @@
 
 package com.android.settings.connecteddevice.usb;
 
-import static android.net.ConnectivityManager.TETHERING_USB;
-
 import static com.google.common.truth.Truth.assertThat;
-
-import static org.mockito.Matchers.anyLong;
-import static org.mockito.Mockito.doNothing;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyZeroInteractions;
 import static org.mockito.Mockito.when;
 
 import android.hardware.usb.UsbManager;
-import android.net.ConnectivityManager;
 
 import com.android.settings.testutils.SettingsRobolectricTestRunner;
 import com.android.settings.testutils.shadow.ShadowUtils;
@@ -40,17 +31,13 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
-import org.robolectric.Robolectric;
 import org.robolectric.annotation.Config;
-import org.robolectric.util.FragmentTestUtil;
 
 @RunWith(SettingsRobolectricTestRunner.class)
 public class UsbDefaultFragmentTest {
 
     @Mock
     private UsbBackend mUsbBackend;
-    @Mock
-    private ConnectivityManager mConnectivityManager;
 
     private UsbDefaultFragment mFragment;
 
@@ -59,7 +46,6 @@ public class UsbDefaultFragmentTest {
         MockitoAnnotations.initMocks(this);
         mFragment = new UsbDefaultFragment();
         mFragment.mUsbBackend = mUsbBackend;
-        mFragment.mConnectivityManager = mConnectivityManager;
     }
 
     @Test
@@ -115,6 +101,12 @@ public class UsbDefaultFragmentTest {
         verify(mUsbBackend).setDefaultUsbFunctions(UsbManager.FUNCTION_PTP);
     }
 
+    @Test
+    public void setDefaultKey_isRndis_shouldSetRndis() {
+        mFragment.setDefaultKey(UsbBackend.usbFunctionsToString(UsbManager.FUNCTION_RNDIS));
+        verify(mUsbBackend).setDefaultUsbFunctions(UsbManager.FUNCTION_RNDIS);
+    }
+
     @Test
     public void setDefaultKey_isMidi_shouldSetMidi() {
         mFragment.setDefaultKey(UsbBackend.usbFunctionsToString(UsbManager.FUNCTION_MIDI));
@@ -126,39 +118,6 @@ public class UsbDefaultFragmentTest {
     public void setDefaultKey_isMonkey_shouldDoNothing() {
         ShadowUtils.setIsUserAMonkey(true);
         mFragment.setDefaultKey(UsbBackend.usbFunctionsToString(UsbManager.FUNCTION_MTP));
-
+        verifyZeroInteractions(mUsbBackend);
-        verify(mUsbBackend, never()).setDefaultUsbFunctions(anyLong());
-    }
-
-    @Test
-    public void setDefaultKey_functionRndis_startTetheringInvoked() {
-        doReturn(UsbManager.FUNCTION_MTP).when(mUsbBackend).getCurrentFunctions();
-
-        mFragment.setDefaultKey(UsbBackend.usbFunctionsToString(UsbManager.FUNCTION_RNDIS));
-
-        verify(mConnectivityManager).startTethering(TETHERING_USB, true,
-                mFragment.mOnStartTetheringCallback);
-        assertThat(mFragment.mPreviousFunctions).isEqualTo(
-                UsbManager.FUNCTION_MTP);
-    }
-
-    @Test
-    public void setDefaultKey_functionOther_setCurrentFunctionInvoked() {
-        doReturn(UsbManager.FUNCTION_MTP).when(mUsbBackend).getCurrentFunctions();
-
-        mFragment.setDefaultKey(UsbBackend.usbFunctionsToString(UsbManager.FUNCTION_PTP));
-
-        verify(mUsbBackend).setDefaultUsbFunctions(UsbManager.FUNCTION_PTP);
-        assertThat(mFragment.mPreviousFunctions).isEqualTo(
-                UsbManager.FUNCTION_MTP);
-    }
-
-    @Test
-    public void onTetheringStarted_setDefaultUsbFunctions() {
-        mFragment.mPreviousFunctions = UsbManager.FUNCTION_PTP;
-
-        mFragment.mOnStartTetheringCallback.onTetheringStarted();
-
-        verify(mUsbBackend).setDefaultUsbFunctions(UsbManager.FUNCTION_RNDIS);
     }
 }

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

@@ -16,14 +16,9 @@
 
 package com.android.settings.connecteddevice.usb;
 
-import static android.net.ConnectivityManager.TETHERING_USB;
-
 import static com.google.common.truth.Truth.assertThat;
 
 import static org.mockito.ArgumentMatchers.anyLong;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
@@ -31,7 +26,6 @@ import android.app.Activity;
 import android.content.Context;
 import android.hardware.usb.UsbManager;
 import android.hardware.usb.UsbPort;
-
 import androidx.preference.PreferenceCategory;
 import androidx.preference.PreferenceManager;
 import androidx.preference.PreferenceScreen;
@@ -59,10 +53,9 @@ public class UsbDetailsFunctionsControllerTest {
     private UsbDetailsFunctionsController mDetailsFunctionsController;
     private Context mContext;
     private Lifecycle mLifecycle;
-    private PreferenceCategory mPreferenceCategory;
+    private PreferenceCategory mPreference;
     private PreferenceManager mPreferenceManager;
     private PreferenceScreen mScreen;
-    private RadioButtonPreference mRadioButtonPreference;
 
     @Mock
     private UsbBackend mUsbBackend;
@@ -70,14 +63,12 @@ public class UsbDetailsFunctionsControllerTest {
     private UsbDetailsFragment mFragment;
     @Mock
     private Activity mActivity;
-    @Mock
-    private ConnectivityManager mConnectivityManager;
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
 
-        mContext = spy(RuntimeEnvironment.application);
+        mContext = RuntimeEnvironment.application;
         mLifecycle = new Lifecycle(() -> mLifecycle);
         mPreferenceManager = new PreferenceManager(mContext);
         mScreen = mPreferenceManager.createPreferenceScreen(mContext);
@@ -87,16 +78,12 @@ public class UsbDetailsFunctionsControllerTest {
         when(mFragment.getContext()).thenReturn(mContext);
         when(mFragment.getPreferenceManager()).thenReturn(mPreferenceManager);
         when(mFragment.getPreferenceScreen()).thenReturn(mScreen);
-        when(mContext.getSystemService(ConnectivityManager.class)).thenReturn(mConnectivityManager);
 
         mDetailsFunctionsController = new UsbDetailsFunctionsController(mContext, mFragment,
                 mUsbBackend);
-        mPreferenceCategory = new PreferenceCategory(mContext);
+        mPreference = new PreferenceCategory(mContext);
-        mPreferenceCategory.setKey(mDetailsFunctionsController.getPreferenceKey());
+        mPreference.setKey(mDetailsFunctionsController.getPreferenceKey());
-        mScreen.addPreference(mPreferenceCategory);
+        mScreen.addPreference(mPreference);
-        mDetailsFunctionsController.displayPreference(mScreen);
-
-        mRadioButtonPreference = new RadioButtonPreference(mContext);
     }
 
     @Test
@@ -118,9 +105,10 @@ public class UsbDetailsFunctionsControllerTest {
     public void displayRefresh_disconnected_shouldDisable() {
         when(mUsbBackend.areFunctionsSupported(anyLong())).thenReturn(true);
 
+        mDetailsFunctionsController.displayPreference(mScreen);
         mDetailsFunctionsController.refresh(false, UsbManager.FUNCTION_NONE,
                 UsbPort.POWER_ROLE_SINK, UsbPort.DATA_ROLE_DEVICE);
-        assertThat(mPreferenceCategory.isEnabled()).isFalse();
+        assertThat(mPreference.isEnabled()).isFalse();
     }
 
     @Test
@@ -130,6 +118,7 @@ public class UsbDetailsFunctionsControllerTest {
         when(mUsbBackend.areFunctionsSupported(UsbManager.FUNCTION_PTP)).thenReturn(false);
         when(mUsbBackend.areFunctionsSupported(UsbManager.FUNCTION_RNDIS)).thenReturn(false);
 
+        mDetailsFunctionsController.displayPreference(mScreen);
         mDetailsFunctionsController.refresh(true, UsbManager.FUNCTION_NONE, UsbPort.POWER_ROLE_SINK,
                 UsbPort.DATA_ROLE_DEVICE);
         List<RadioButtonPreference> prefs = getRadioPreferences();
@@ -142,6 +131,7 @@ public class UsbDetailsFunctionsControllerTest {
     public void displayRefresh_mtpEnabled_shouldCheckSwitches() {
         when(mUsbBackend.areFunctionsSupported(anyLong())).thenReturn(true);
 
+        mDetailsFunctionsController.displayPreference(mScreen);
         mDetailsFunctionsController.refresh(true, UsbManager.FUNCTION_MTP, UsbPort.POWER_ROLE_SINK,
                 UsbPort.DATA_ROLE_DEVICE);
         List<RadioButtonPreference> prefs = getRadioPreferences();
@@ -155,6 +145,7 @@ public class UsbDetailsFunctionsControllerTest {
     public void onClickMtp_noneEnabled_shouldEnableMtp() {
         when(mUsbBackend.areFunctionsSupported(anyLong())).thenReturn(true);
 
+        mDetailsFunctionsController.displayPreference(mScreen);
         mDetailsFunctionsController.refresh(true, UsbManager.FUNCTION_NONE, UsbPort.POWER_ROLE_SINK,
                 UsbPort.DATA_ROLE_DEVICE);
         when(mUsbBackend.getCurrentFunctions()).thenReturn(UsbManager.FUNCTION_NONE);
@@ -173,6 +164,7 @@ public class UsbDetailsFunctionsControllerTest {
     public void onClickMtp_ptpEnabled_shouldEnableMtp() {
         when(mUsbBackend.areFunctionsSupported(anyLong())).thenReturn(true);
 
+        mDetailsFunctionsController.displayPreference(mScreen);
         mDetailsFunctionsController.refresh(true, UsbManager.FUNCTION_PTP, UsbPort.POWER_ROLE_SINK,
                 UsbPort.DATA_ROLE_DEVICE);
         when(mUsbBackend.getCurrentFunctions()).thenReturn(UsbManager.FUNCTION_PTP);
@@ -194,6 +186,7 @@ public class UsbDetailsFunctionsControllerTest {
     public void onClickNone_mtpEnabled_shouldDisableMtp() {
         when(mUsbBackend.areFunctionsSupported(anyLong())).thenReturn(true);
 
+        mDetailsFunctionsController.displayPreference(mScreen);
         mDetailsFunctionsController.refresh(true, UsbManager.FUNCTION_MTP, UsbPort.POWER_ROLE_SINK,
                 UsbPort.DATA_ROLE_DEVICE);
         when(mUsbBackend.getCurrentFunctions()).thenReturn(UsbManager.FUNCTION_MTP);
@@ -217,55 +210,9 @@ public class UsbDetailsFunctionsControllerTest {
 
     private List<RadioButtonPreference> getRadioPreferences() {
         ArrayList<RadioButtonPreference> result = new ArrayList<>();
-        for (int i = 0; i < mPreferenceCategory.getPreferenceCount(); i++) {
+        for (int i = 0; i < mPreference.getPreferenceCount(); i++) {
-            result.add((RadioButtonPreference) mPreferenceCategory.getPreference(i));
+            result.add((RadioButtonPreference) mPreference.getPreference(i));
         }
         return result;
     }
-
-    @Test
-    public void onRadioButtonClicked_functionRndis_startTetheringInvoked() {
-        mRadioButtonPreference.setKey(UsbBackend.usbFunctionsToString(UsbManager.FUNCTION_RNDIS));
-        doReturn(UsbManager.FUNCTION_MTP).when(mUsbBackend).getCurrentFunctions();
-
-        mDetailsFunctionsController.onRadioButtonClicked(mRadioButtonPreference);
-
-        verify(mConnectivityManager).startTethering(TETHERING_USB, true,
-                mDetailsFunctionsController.mOnStartTetheringCallback);
-        assertThat(mDetailsFunctionsController.mPreviousFunction).isEqualTo(
-                UsbManager.FUNCTION_MTP);
-    }
-
-    @Test
-    public void onRadioButtonClicked_functionOther_setCurrentFunctionInvoked() {
-        mRadioButtonPreference.setKey(UsbBackend.usbFunctionsToString(UsbManager.FUNCTION_PTP));
-        doReturn(UsbManager.FUNCTION_MTP).when(mUsbBackend).getCurrentFunctions();
-
-        mDetailsFunctionsController.onRadioButtonClicked(mRadioButtonPreference);
-
-        verify(mUsbBackend).setCurrentFunctions(UsbManager.FUNCTION_PTP);
-        assertThat(mDetailsFunctionsController.mPreviousFunction).isEqualTo(
-                UsbManager.FUNCTION_MTP);
-    }
-
-    @Test
-    public void onRadioButtonClicked_clickSameButton_doNothing() {
-        mRadioButtonPreference.setKey(UsbBackend.usbFunctionsToString(UsbManager.FUNCTION_PTP));
-        doReturn(UsbManager.FUNCTION_PTP).when(mUsbBackend).getCurrentFunctions();
-
-        mDetailsFunctionsController.onRadioButtonClicked(mRadioButtonPreference);
-
-        verify(mUsbBackend, never()).setCurrentFunctions(UsbManager.FUNCTION_PTP);
-        verify(mConnectivityManager, never()).startTethering(TETHERING_USB, true,
-                mDetailsFunctionsController.mOnStartTetheringCallback);
-    }
-
-    @Test
-    public void onTetheringFailed_resetPreviousFunctions() {
-        mDetailsFunctionsController.mPreviousFunction = UsbManager.FUNCTION_PTP;
-
-        mDetailsFunctionsController.mOnStartTetheringCallback.onTetheringFailed();
-
-        verify(mUsbBackend).setCurrentFunctions(UsbManager.FUNCTION_PTP);
-    }
 }