Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 73c361b5 authored by Lei Yu's avatar Lei Yu
Browse files

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

This reverts commit e81224d8.

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

Change-Id: Ib45b96216017d01b6301a558a0cd27bf1071779c
Merged-In: I3d2ebad2879479a870bcdfe596bb88b83c424389
parent e81224d8

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

+1 −41
Original line number Diff line number Diff line
@@ -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();

        }

    }

}
 
 No newline at end of file

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

+3 −46
Original line number Diff line number Diff line
@@ -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());

        final long previousFunction = mUsbBackend.getCurrentFunctions();

        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 {

        long function = UsbBackend.usbFunctionsFromString(preference.getKey());

        if (function != mUsbBackend.getCurrentFunctions() && !Utils.isMonkeyRunning()) {

            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

+7 −48
Original line number Diff line number Diff line
@@ -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));



        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);

        verifyZeroInteractions(mUsbBackend);

    }

}

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

+14 −67
Original line number Diff line number Diff line
@@ -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);

        mPreferenceCategory.setKey(mDetailsFunctionsController.getPreferenceKey());

        mScreen.addPreference(mPreferenceCategory);

        mDetailsFunctionsController.displayPreference(mScreen);



        mRadioButtonPreference = new RadioButtonPreference(mContext);

        mPreference = new PreferenceCategory(mContext);

        mPreference.setKey(mDetailsFunctionsController.getPreferenceKey());

        mScreen.addPreference(mPreference);

    }



    @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++) {

            result.add((RadioButtonPreference) mPreferenceCategory.getPreference(i));

        for (int i = 0; i < mPreference.getPreferenceCount(); 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);

    }

}