Merge changes from topic "adbwifi-bugs"

* changes:
  Add toast error message for no WiFi on wireless debugging.
  Add visibility control to ADB QR code preference.

res/xml/adb_wireless_settings.xml

@@ -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"

src/com/android/settings/development/AdbQrCodePreferenceController.java

@@ -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;
+    }
+}

src/com/android/settings/development/AdbQrcodeScannerFragment.java

@@ -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();
         }
     }

src/com/android/settings/development/WirelessDebuggingEnabler.java

@@ -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;
     }

src/com/android/settings/development/WirelessDebuggingFragment.java

@@ -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;
+    static final int PAIRED_DEVICE_REQUEST = 0;
-    public static final String PAIRED_DEVICE_REQUEST_TYPE = "request_type";
+    static final String PAIRED_DEVICE_REQUEST_TYPE = "request_type";
-    public static final int FORGET_ACTION = 0;
+    static final int FORGET_ACTION = 0;
-
     // Activity result from pairing a device.
-    private static final int PAIRING_DEVICE_REQUEST = 1;
+    static final int PAIRING_DEVICE_REQUEST = 1;
-    public static final String PAIRING_DEVICE_REQUEST_TYPE = "request_type_pairing";
+    static final String PAIRING_DEVICE_REQUEST_TYPE = "request_type_pairing";
-    public static final int SUCCESS_ACTION = 0;
+    static final int SUCCESS_ACTION = 0;
-    public static final int FAIL_ACTION = 1;
+    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) {

src/com/android/settings/development/WirelessDebuggingPreferenceController.java

@@ -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

tests/robotests/src/com/android/settings/development/AdbQrCodePreferenceControllerTest.java

@@ -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));
+    }
+}

tests/robotests/src/com/android/settings/development/WirelessDebuggingEnablerTest.java

@@ -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);
+                Global.ADB_WIFI_ENABLED, -1)).isEqualTo(0);
-        // Should also get a callback
+    }
+
+    @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);
     }
 }

tests/robotests/src/com/android/settings/development/WirelessDebuggingPreferenceControllerTest.java

@@ -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);
+    }
 }

tests/robotests/src/com/android/settings/testutils/shadow/ShadowWirelessDebuggingPreferenceController.java

@@ -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;
+    }
+}