PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge changes from topic "adbwifi-bugs"

Browse Source 
* changes:
  Add toast error message for no WiFi on wireless debugging.
  Add visibility control to ADB QR code preference.
This commit is contained in:
Joshua Duong
2020-03-20 15:07:14 +00:00
committed by Android (Google) Code Review
parent 99a3ae966a 564f6ba770
commit 04bc02223e
10 changed files with 391 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
res/xml/adb_wireless_settings.xml
View File

@@ -47,7 +47,8 @@
android:key="adb_pair_method_qrcode_pref"
android:icon="@drawable/ic_scan_24dp"
android:title="@string/adb_pair_method_qrcode_title"
android:summary="@string/adb_pair_method_qrcode_summary"/>
android:summary="@string/adb_pair_method_qrcode_summary"
settings:controller="com.android.settings.development.AdbQrCodePreferenceController"/>
<Preference
android:key="adb_pair_method_code_pref"
android:title="@string/adb_pair_method_code_title"

79
src/com/android/settings/development/AdbQrCodePreferenceController.java Normal file
View File

@@ -0,0 +1,79 @@
/*
* Copyright (C) 2020 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.settings.development;
import android.app.settings.SettingsEnums;
import android.content.Context;
import android.debug.IAdbManager;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.text.TextUtils;
import android.util.Log;
import androidx.fragment.app.Fragment;
import androidx.preference.Preference;
import com.android.settings.core.BasePreferenceController;
import com.android.settings.core.SubSettingLauncher;
/**
* Controller for the "Pair device with QR code" preference in the Wireless debugging
* fragment.
*/
public class AdbQrCodePreferenceController extends BasePreferenceController {
private static final String TAG = "AdbQrCodePrefCtrl";
private IAdbManager mAdbManager;
private Fragment mParentFragment;
public AdbQrCodePreferenceController(Context context, String key) {
super(context, key);
mAdbManager = IAdbManager.Stub.asInterface(ServiceManager.getService(
Context.ADB_SERVICE));
}
public void setParentFragment(Fragment parent) {
mParentFragment = parent;
}
@Override
public int getAvailabilityStatus() {
try {
return mAdbManager.isAdbWifiQrSupported() ? AVAILABLE : UNSUPPORTED_ON_DEVICE;
} catch (RemoteException e) {
Log.e(TAG, "Unable to check if adb wifi QR code scanning is supported.", e);
}
return UNSUPPORTED_ON_DEVICE;
}
@Override
public boolean handlePreferenceTreeClick(Preference preference) {
if (!TextUtils.equals(preference.getKey(), getPreferenceKey())) {
return false;
}
new SubSettingLauncher(preference.getContext())
.setDestination(AdbQrcodeScannerFragment.class.getName())
.setSourceMetricsCategory(SettingsEnums.SETTINGS_ADB_WIRELESS)
.setResultListener(mParentFragment,
WirelessDebuggingFragment.PAIRING_DEVICE_REQUEST)
.launch();
return true;
}
}

2
src/com/android/settings/development/AdbQrcodeScannerFragment.java
View File

@@ -193,6 +193,7 @@ public class AdbQrcodeScannerFragment extends WifiDppQrCodeBaseFragment implemen
} catch (RemoteException e) {
Log.e(TAG, "Unable to cancel pairing");
}
getActivity().setResult(Activity.RESULT_CANCELED);
getActivity().finish();
}
@@ -268,6 +269,7 @@ public class AdbQrcodeScannerFragment extends WifiDppQrCodeBaseFragment implemen
mAdbConfig.getPreSharedKey());
} catch (RemoteException e) {
Log.e(TAG, "Unable to enable QR code pairing");
getActivity().setResult(Activity.RESULT_CANCELED);
getActivity().finish();
}
}

11
src/com/android/settings/development/WirelessDebuggingEnabler.java
View File

@@ -24,7 +24,9 @@ import android.os.Handler;
import android.os.Looper;
import android.provider.Settings;
import android.util.Log;
import android.widget.Toast;
import com.android.settings.R;
import com.android.settings.widget.SwitchWidgetController;
import com.android.settingslib.core.lifecycle.Lifecycle;
import com.android.settingslib.core.lifecycle.LifecycleObserver;
@@ -121,6 +123,15 @@ public class WirelessDebuggingEnabler implements SwitchWidgetController.OnSwitch
@Override
public boolean onSwitchToggled(boolean isChecked) {
if (isChecked && !WirelessDebuggingPreferenceController.isWifiConnected(mContext)) {
// No connected Wi-Fi network. Reset the switch to off.
Toast.makeText(
mContext, R.string.adb_wireless_no_network_msg, Toast.LENGTH_LONG)
.show();
mSwitchWidget.setChecked(false);
return false;
}
writeAdbWifiSetting(isChecked);
return true;
}

90
src/com/android/settings/development/WirelessDebuggingFragment.java
View File

@@ -63,66 +63,44 @@ public class WirelessDebuggingFragment extends DashboardFragment
private static final String TAG = "WirelessDebuggingFrag";
// Activity result from clicking on a paired device.
private static final int PAIRED_DEVICE_REQUEST = 0;
public static final String PAIRED_DEVICE_REQUEST_TYPE = "request_type";
public static final int FORGET_ACTION = 0;
static final int PAIRED_DEVICE_REQUEST = 0;
static final String PAIRED_DEVICE_REQUEST_TYPE = "request_type";
static final int FORGET_ACTION = 0;
// Activity result from pairing a device.
private static final int PAIRING_DEVICE_REQUEST = 1;
public static final String PAIRING_DEVICE_REQUEST_TYPE = "request_type_pairing";
public static final int SUCCESS_ACTION = 0;
public static final int FAIL_ACTION = 1;
static final int PAIRING_DEVICE_REQUEST = 1;
static final String PAIRING_DEVICE_REQUEST_TYPE = "request_type_pairing";
static final int SUCCESS_ACTION = 0;
static final int FAIL_ACTION = 1;
static final String PAIRED_DEVICE_EXTRA = "paired_device";
static final String DEVICE_NAME_EXTRA = "device_name";
static final String IP_ADDR_EXTRA = "ip_addr";
public static final String PAIRED_DEVICE_EXTRA = "paired_device";
public static final String DEVICE_NAME_EXTRA = "device_name";
public static final String IP_ADDR_EXTRA = "ip_addr";
private WirelessDebuggingEnabler mWifiDebuggingEnabler;
private static AdbIpAddressPreferenceController sAdbIpAddressPreferenceController;
// UI components
private static final String PREF_KEY_ADB_DEVICE_NAME = "adb_device_name_pref";
private static final String PREF_KEY_ADB_IP_ADDR = "adb_ip_addr_pref";
private static final String PREF_KEY_PAIRING_METHODS_CATEGORY = "adb_pairing_methods_category";
private static final String PREF_KEY_ADB_QRCODE_PAIRING = "adb_pair_method_qrcode_pref";
private static final String PREF_KEY_ADB_CODE_PAIRING = "adb_pair_method_code_pref";
private static final String PREF_KEY_PAIRED_DEVICES_CATEGORY = "adb_paired_devices_category";
private static final String PREF_KEY_FOOTER_CATEGORY = "adb_wireless_footer_category";
private static AdbIpAddressPreferenceController sAdbIpAddressPreferenceController;
private final PairingCodeDialogListener mPairingCodeDialogListener =
new PairingCodeDialogListener();
private WirelessDebuggingEnabler mWifiDebuggingEnabler;
private Preference mDeviceNamePreference;
private Preference mIpAddrPreference;
private PreferenceCategory mPairingMethodsCategory;
private Preference mQrcodePairingPreference;
private Preference mCodePairingPreference;
private PreferenceCategory mPairedDevicesCategory;
private PreferenceCategory mFooterCategory;
private FooterPreference mOffMessagePreference;
// Map of paired devices, with the device GUID is the key
private Map<String, AdbPairedDevicePreference> mPairedDevicePreferences;
private IAdbManager mAdbManager;
private int mConnectionPort;
class PairingCodeDialogListener implements AdbWirelessDialog.AdbWirelessDialogListener {
@Override
public void onDismiss() {
Log.i(TAG, "onDismiss");
mPairingCodeDialog = null;
try {
mAdbManager.disablePairing();
} catch (RemoteException e) {
Log.e(TAG, "Unable to cancel pairing");
}
}
}
final PairingCodeDialogListener mPairingCodeDialogListener = new PairingCodeDialogListener();
AdbWirelessDialog mPairingCodeDialog;
private IntentFilter mIntentFilter;
private AdbWirelessDialog mPairingCodeDialog;
private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
@@ -171,6 +149,25 @@ public class WirelessDebuggingFragment extends DashboardFragment
}
};
class PairingCodeDialogListener implements AdbWirelessDialog.AdbWirelessDialogListener {
@Override
public void onDismiss() {
Log.i(TAG, "onDismiss");
mPairingCodeDialog = null;
try {
mAdbManager.disablePairing();
} catch (RemoteException e) {
Log.e(TAG, "Unable to cancel pairing");
}
}
}
@Override
public void onAttach(Context context) {
super.onAttach(context);
use(AdbQrCodePreferenceController.class).setParentFragment(this);
}
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
@@ -203,12 +200,6 @@ public class WirelessDebuggingFragment extends DashboardFragment
showDialog(AdbWirelessDialogUiBase.MODE_PAIRING);
return true;
});
mQrcodePairingPreference =
(Preference) findPreference(PREF_KEY_ADB_QRCODE_PAIRING);
mQrcodePairingPreference.setOnPreferenceClickListener(preference -> {
launchQrcodeScannerFragment();
return true;
});
mPairedDevicesCategory =
(PreferenceCategory) findPreference(PREF_KEY_PAIRED_DEVICES_CATEGORY);
@@ -462,6 +453,7 @@ public class WirelessDebuggingFragment extends DashboardFragment
showDialog(AdbWirelessDialogUiBase.MODE_PAIRING_FAILED);
break;
default:
Log.d(TAG, "Successfully paired device");
break;
}
}
@@ -476,16 +468,8 @@ public class WirelessDebuggingFragment extends DashboardFragment
return deviceName;
}
private void launchQrcodeScannerFragment() {
new SubSettingLauncher(getContext())
.setDestination(AdbQrcodeScannerFragment.class.getName())
.setSourceMetricsCategory(getMetricsCategory())
.setResultListener(this, PAIRING_DEVICE_REQUEST)
.launch();
}
public static final BaseSearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
new BaseSearchIndexProvider(R.xml.development_tile_settings) {
new BaseSearchIndexProvider(R.xml.adb_wireless_settings) {
@Override
protected boolean isPageSearchEnabled(Context context) {

24
src/com/android/settings/development/WirelessDebuggingPreferenceController.java
View File

@@ -19,6 +19,8 @@ import android.content.ContentResolver;
import android.content.Context;
import android.database.ContentObserver;
import android.debug.IAdbManager;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.Uri;
import android.os.Handler;
import android.os.Looper;
@@ -26,10 +28,12 @@ import android.os.RemoteException;
import android.os.ServiceManager;
import android.provider.Settings;
import android.util.Log;
import android.widget.Toast;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.settings.R;
import com.android.settings.core.PreferenceControllerMixin;
import com.android.settings.widget.MasterSwitchPreference;
import com.android.settingslib.core.lifecycle.Lifecycle;
@@ -131,9 +135,29 @@ public class WirelessDebuggingPreferenceController extends DeveloperOptionsPrefe
((MasterSwitchPreference) preference).setChecked(enabled);
}
static boolean isWifiConnected(Context context) {
ConnectivityManager cm = (ConnectivityManager) context.getSystemService(
Context.CONNECTIVITY_SERVICE);
if (cm != null) {
NetworkInfo info = cm.getActiveNetworkInfo();
if (info != null && info.isConnected()) {
return info.getType() == ConnectivityManager.TYPE_WIFI;
}
}
return false;
}
@Override
public boolean onPreferenceChange(Preference preference, Object newValue) {
final boolean enabled = (Boolean) newValue;
if (enabled && !isWifiConnected(mContext)) {
// Cannot enable ADB over Wi-Fi if we're not connected to wifi.
Toast.makeText(
mContext, R.string.adb_wireless_no_network_msg, Toast.LENGTH_LONG)
.show();
return false;
}
Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.ADB_WIFI_ENABLED,
enabled ? AdbPreferenceController.ADB_SETTING_ON

118
tests/robotests/src/com/android/settings/development/AdbQrCodePreferenceControllerTest.java Normal file
View File

@@ -0,0 +1,118 @@
/*
* Copyright (C) 2020 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.settings.development;
import static com.android.settings.core.BasePreferenceController.AVAILABLE;
import static com.android.settings.core.BasePreferenceController.UNSUPPORTED_ON_DEVICE;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import android.content.Context;
import android.content.Intent;
import android.debug.IAdbManager;
import android.os.RemoteException;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.settings.testutils.shadow.ShadowUtils;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
import org.robolectric.util.ReflectionHelpers;
@RunWith(RobolectricTestRunner.class)
@Config(shadows = ShadowUtils.class)
public class AdbQrCodePreferenceControllerTest {
@Mock
private PreferenceScreen mScreen;
@Mock
private Preference mPreference;
@Mock
private IAdbManager mAdbManager;
@Mock
private WirelessDebuggingFragment mFragment;
private AdbQrCodePreferenceController mController;
private Context mContext;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = RuntimeEnvironment.application;
mController = spy(new AdbQrCodePreferenceController(mContext, "test_key"));
mController.setParentFragment(mFragment);
ReflectionHelpers.setField(mController, "mAdbManager", mAdbManager);
when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference);
when(mPreference.getContext()).thenReturn(mContext);
}
@Test
public void getAvailabilityStatus_isAdbWifiQrSupported_yes_shouldBeTrue()
throws RemoteException {
when(mAdbManager.isAdbWifiQrSupported()).thenReturn(true);
assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
}
@Test
public void getAvailabilityStatus_isAdbWifiQrSupported_no_shouldBeFalse()
throws RemoteException {
when(mAdbManager.isAdbWifiQrSupported()).thenReturn(false);
assertThat(mController.getAvailabilityStatus()).isEqualTo(UNSUPPORTED_ON_DEVICE);
}
@Test
public void displayPreference_isAdbWifiQrSupported_yes_prefIsVisible() throws RemoteException {
when(mAdbManager.isAdbWifiQrSupported()).thenReturn(true);
mController.displayPreference(mScreen);
verify(mPreference).setVisible(true);
}
@Test
public void displayPreference_isAdbWifiQrSupported_no_prefIsNotVisible()
throws RemoteException {
when(mAdbManager.isAdbWifiQrSupported()).thenReturn(false);
mController.displayPreference(mScreen);
verify(mPreference).setVisible(false);
}
@Test
public void handlePreferenceTreeClick_launchActivity() {
final String preferenceKey = mController.getPreferenceKey();
when(mPreference.getKey()).thenReturn(preferenceKey);
mController.handlePreferenceTreeClick(mPreference);
verify(mFragment).startActivityForResult(any(Intent.class),
eq(WirelessDebuggingFragment.PAIRING_DEVICE_REQUEST));
}
}

51
tests/robotests/src/com/android/settings/development/WirelessDebuggingEnablerTest.java
View File

@@ -28,10 +28,12 @@ import android.provider.Settings.Global;
import androidx.lifecycle.LifecycleOwner;
import com.android.settings.testutils.shadow.ShadowUtils;
import com.android.settings.testutils.shadow.ShadowWirelessDebuggingPreferenceController;
import com.android.settings.widget.SwitchBar;
import com.android.settings.widget.SwitchBarController;
import com.android.settingslib.core.lifecycle.Lifecycle;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -43,7 +45,7 @@ import org.robolectric.annotation.Config;
import org.robolectric.util.ReflectionHelpers;
@RunWith(RobolectricTestRunner.class)
@Config(shadows = ShadowUtils.class)
@Config(shadows = {ShadowUtils.class, ShadowWirelessDebuggingPreferenceController.class})
public class WirelessDebuggingEnablerTest {
@Mock
@@ -66,6 +68,11 @@ public class WirelessDebuggingEnablerTest {
mContext, new SwitchBarController(mSwitchBar), mListener, mLifecycle));
}
@After
public void tearDown() {
ShadowWirelessDebuggingPreferenceController.reset();
}
@Test
public void onCreation_shouldShowSwitchBar() {
verify(mSwitchBar).show();
@@ -120,7 +127,8 @@ public class WirelessDebuggingEnablerTest {
}
@Test
public void onSwitchToggled_true_shouldSetAdbWifiEnabledTrue() {
public void onSwitchToggled_true_wifiConnected_shouldSetAdbWifiEnabledTrue() {
ShadowWirelessDebuggingPreferenceController.setIsWifiConnected(true);
Global.putInt(mContext.getContentResolver(),
Global.ADB_WIFI_ENABLED, 0 /* setting disabled */);
mWirelessDebuggingEnabler.onResume();
@@ -132,11 +140,27 @@ public class WirelessDebuggingEnablerTest {
assertThat(Global.getInt(mContext.getContentResolver(),
Global.ADB_WIFI_ENABLED, -1)).isEqualTo(1);
// Should also get a callback
}
@Test
public void onSwitchToggled_false_shouldSetAdbWifiEnabledFalse() {
public void onSwitchToggled_true_wifiNotConnected_shouldSetAdbWifiEnabledFalse() {
ShadowWirelessDebuggingPreferenceController.setIsWifiConnected(false);
Global.putInt(mContext.getContentResolver(),
Global.ADB_WIFI_ENABLED, 0 /* setting disabled */);
mWirelessDebuggingEnabler.onResume();
verify(mSwitchBar).setChecked(false);
verify(mListener).onEnabled(false);
mWirelessDebuggingEnabler.onSwitchToggled(true);
assertThat(Global.getInt(mContext.getContentResolver(),
Global.ADB_WIFI_ENABLED, -1)).isEqualTo(0);
}
@Test
public void onSwitchToggled_false_wifiConnected_shouldSetAdbWifiEnabledFalse() {
ShadowWirelessDebuggingPreferenceController.setIsWifiConnected(true);
Global.putInt(mContext.getContentResolver(),
Global.ADB_WIFI_ENABLED, 1 /* setting disabled */);
mWirelessDebuggingEnabler.onResume();
@@ -147,7 +171,22 @@ public class WirelessDebuggingEnablerTest {
mWirelessDebuggingEnabler.onSwitchToggled(false);
assertThat(Global.getInt(mContext.getContentResolver(),
Global.ADB_WIFI_ENABLED, -1)).isEqualTo(0);
// Should also get a callback
Global.ADB_WIFI_ENABLED, -1)).isEqualTo(0);
}
@Test
public void onSwitchToggled_false_wifiNotConnected_shouldSetAdbWifiEnabledFalse() {
ShadowWirelessDebuggingPreferenceController.setIsWifiConnected(false);
Global.putInt(mContext.getContentResolver(),
Global.ADB_WIFI_ENABLED, 1 /* setting disabled */);
mWirelessDebuggingEnabler.onResume();
verify(mSwitchBar).setChecked(true);
verify(mListener).onEnabled(true);
mWirelessDebuggingEnabler.onSwitchToggled(false);
assertThat(Global.getInt(mContext.getContentResolver(),
Global.ADB_WIFI_ENABLED, -1)).isEqualTo(0);
}
}

33
tests/robotests/src/com/android/settings/development/WirelessDebuggingPreferenceControllerTest.java
View File

@@ -32,6 +32,7 @@ import androidx.lifecycle.LifecycleOwner;
import androidx.preference.PreferenceScreen;
import com.android.settings.testutils.shadow.ShadowUtils;
import com.android.settings.testutils.shadow.ShadowWirelessDebuggingPreferenceController;
import com.android.settings.widget.MasterSwitchPreference;
import com.android.settingslib.core.lifecycle.Lifecycle;
@@ -47,7 +48,7 @@ import org.robolectric.annotation.Config;
import org.robolectric.util.ReflectionHelpers;
@RunWith(RobolectricTestRunner.class)
@Config(shadows = ShadowUtils.class)
@Config(shadows = {ShadowUtils.class, ShadowWirelessDebuggingPreferenceController.class})
public class WirelessDebuggingPreferenceControllerTest {
@Mock
@@ -75,10 +76,12 @@ public class WirelessDebuggingPreferenceControllerTest {
mController = spy(new WirelessDebuggingPreferenceController(mContext, mLifecycle));
ReflectionHelpers.setField(mController, "mAdbManager", mAdbManager);
when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference);
Global.putInt(mContentResolver, Global.ADB_WIFI_ENABLED, 0);
}
@After
public void tearDown() {
ShadowWirelessDebuggingPreferenceController.reset();
}
@Test
@@ -112,9 +115,35 @@ public class WirelessDebuggingPreferenceControllerTest {
}
@Test
public void onPreferenceChange_turnOn_adbWifiEnabledTrue() {
public void onPreferenceChange_turnOn_wifiConnected_adbWifiEnabledTrue() {
ShadowWirelessDebuggingPreferenceController.setIsWifiConnected(true);
mController.onPreferenceChange(null, true);
assertThat(Global.getInt(mContentResolver, Global.ADB_WIFI_ENABLED, -1)).isEqualTo(1);
}
@Test
public void onPreferenceChange_turnOff_wifiConnected_adbWifiEnabledFalse() {
ShadowWirelessDebuggingPreferenceController.setIsWifiConnected(true);
mController.onPreferenceChange(null, false);
assertThat(Global.getInt(mContentResolver, Global.ADB_WIFI_ENABLED, -1)).isEqualTo(0);
}
@Test
public void onPreferenceChange_turnOn_wifiNotConnected_adbWifiEnabledFalse() {
// Should not be able to enable wifi debugging without being connected to a wifi network
ShadowWirelessDebuggingPreferenceController.setIsWifiConnected(false);
mController.onPreferenceChange(null, true);
assertThat(Global.getInt(mContentResolver, Global.ADB_WIFI_ENABLED, -1)).isEqualTo(0);
}
@Test
public void onPreferenceChange_turnOff_wifiNotConnected_adbWifiEnabledFalse() {
ShadowWirelessDebuggingPreferenceController.setIsWifiConnected(false);
mController.onPreferenceChange(null, false);
assertThat(Global.getInt(mContentResolver, Global.ADB_WIFI_ENABLED, -1)).isEqualTo(0);
}
}

42
tests/robotests/src/com/android/settings/testutils/shadow/ShadowWirelessDebuggingPreferenceController.java Normal file
View File

@@ -0,0 +1,42 @@
/*
* Copyright (C) 2017 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.settings.testutils.shadow;
import android.content.Context;
import com.android.settings.development.WirelessDebuggingPreferenceController;
import org.robolectric.annotation.Implementation;
import org.robolectric.annotation.Implements;
@Implements(WirelessDebuggingPreferenceController.class)
public class ShadowWirelessDebuggingPreferenceController {
private static boolean sIsWifiConnected;
public static void setIsWifiConnected(boolean isConnected) {
sIsWifiConnected = isConnected;
}
public static void reset() {
sIsWifiConnected = false;
}
@Implementation
protected static boolean isWifiConnected(Context context) {
return sIsWifiConnected;
}
}