src/com/android/settings/wifi/WifiSettings.java

   1 /*
   2  * Copyright (C) 2010 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.settings.wifi;
  18
  19 import static android.os.UserManager.DISALLOW_CONFIG_WIFI;
  20
  21 import android.annotation.NonNull;
  22 import android.app.Activity;
  23 import android.app.Dialog;
  24 import android.app.admin.DevicePolicyManager;
  25 import android.content.ComponentName;
  26 import android.content.ContentResolver;
  27 import android.content.Context;
  28 import android.content.Intent;
  29 import android.content.pm.PackageManager;
  30 import android.content.pm.PackageManager.NameNotFoundException;
  31 import android.content.res.Resources;
  32 import android.net.ConnectivityManager;
  33 import android.net.NetworkInfo;
  34 import android.net.NetworkInfo.State;
  35 import android.net.wifi.WifiConfiguration;
  36 import android.net.wifi.WifiManager;
  37 import android.net.wifi.WpsInfo;
  38 import android.nfc.NfcAdapter;
  39 import android.os.Bundle;
  40 import android.os.HandlerThread;
  41 import android.os.Process;
  42 import android.provider.Settings;
  43 import android.support.annotation.VisibleForTesting;
  44 import android.support.v7.preference.Preference;
  45 import android.support.v7.preference.PreferenceCategory;
  46 import android.util.Log;
  47 import android.view.ContextMenu;
  48 import android.view.ContextMenu.ContextMenuInfo;
  49 import android.view.Menu;
  50 import android.view.MenuItem;
  51 import android.view.View;
  52 import android.widget.ProgressBar;
  53 import android.widget.Toast;
  54
  55 import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
  56 import com.android.settings.LinkifyUtils;
  57 import com.android.settings.R;
  58 import com.android.settings.RestrictedSettingsFragment;
  59 import com.android.settings.SettingsActivity;
  60 import com.android.settings.dashboard.SummaryLoader;
  61 import com.android.settings.location.ScanningSettings;
  62 import com.android.settings.search.BaseSearchIndexProvider;
  63 import com.android.settings.search.Indexable;
  64 import com.android.settings.search.SearchIndexableRaw;
  65 import com.android.settings.widget.SummaryUpdater.OnSummaryChangeListener;
  66 import com.android.settings.widget.SwitchBarController;
  67 import com.android.settings.wifi.details.WifiNetworkDetailsFragment;
  68 import com.android.settingslib.RestrictedLockUtils;
  69 import com.android.settingslib.wifi.AccessPoint;
  70 import com.android.settingslib.wifi.AccessPoint.AccessPointListener;
  71 import com.android.settingslib.wifi.AccessPointPreference;
  72 import com.android.settingslib.wifi.WifiTracker;
  73 import com.android.settingslib.wifi.WifiTrackerFactory;
  74
  75 import java.util.ArrayList;
  76 import java.util.List;
  77
  78 /**
  79  * Two types of UI are provided here.
  80  *
  81  * The first is for "usual Settings", appearing as any other Setup fragment.
  82  *
  83  * The second is for Setup Wizard, with a simplified interface that hides the action bar
  84  * and menus.
  85  */
  86 public class WifiSettings extends RestrictedSettingsFragment
  87         implements Indexable, WifiTracker.WifiListener, AccessPointListener,
  88         WifiDialog.WifiDialogListener {
  89
  90     private static final String TAG = "WifiSettings";
  91     private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
  92
  93     /* package */ static final int MENU_ID_WPS_PBC = Menu.FIRST;
  94     private static final int MENU_ID_WPS_PIN = Menu.FIRST + 1;
  95     private static final int MENU_ID_CONNECT = Menu.FIRST + 6;
  96     private static final int MENU_ID_FORGET = Menu.FIRST + 7;
  97     private static final int MENU_ID_MODIFY = Menu.FIRST + 8;
  98     private static final int MENU_ID_WRITE_NFC = Menu.FIRST + 9;
  99
 100     public static final int WIFI_DIALOG_ID = 1;
 101     /* package */ static final int WPS_PBC_DIALOG_ID = 2;
 102     private static final int WPS_PIN_DIALOG_ID = 3;
 103     private static final int WRITE_NFC_DIALOG_ID = 6;
 104
 105     // Instance state keys
 106     private static final String SAVE_DIALOG_MODE = "dialog_mode";
 107     private static final String SAVE_DIALOG_ACCESS_POINT_STATE = "wifi_ap_state";
 108     private static final String SAVED_WIFI_NFC_DIALOG_STATE = "wifi_nfc_dlg_state";
 109
 110     private static final String PREF_KEY_EMPTY_WIFI_LIST = "wifi_empty_list";
 111     private static final String PREF_KEY_CONNECTED_ACCESS_POINTS = "connected_access_point";
 112     private static final String PREF_KEY_ACCESS_POINTS = "access_points";
 113     private static final String PREF_KEY_ADDITIONAL_SETTINGS = "additional_settings";
 114     private static final String PREF_KEY_CONFIGURE_WIFI_SETTINGS = "configure_settings";
 115     private static final String PREF_KEY_SAVED_NETWORKS = "saved_networks";
 116
 117     private final Runnable mUpdateAccessPointsRunnable = () -> {
 118         updateAccessPointPreferences();
 119     };
 120     private final Runnable mHideProgressBarRunnable = () -> {
 121         setProgressBarVisible(false);
 122     };
 123
 124     protected WifiManager mWifiManager;
 125     private WifiManager.ActionListener mConnectListener;
 126     private WifiManager.ActionListener mSaveListener;
 127     private WifiManager.ActionListener mForgetListener;
 128
 129     /**
 130      * The state of {@link #isUiRestricted()} at {@link #onCreate(Bundle)}}. This is neccesary to
 131      * ensure that behavior is consistent if {@link #isUiRestricted()} changes. It could be changed
 132      * by the Test DPC tool in AFW mode.
 133      */
 134     private boolean mIsRestricted;
 135
 136     private WifiEnabler mWifiEnabler;
 137     // An access point being editted is stored here.
 138     private AccessPoint mSelectedAccessPoint;
 139
 140     private WifiDialog mDialog;
 141     private WriteWifiConfigToNfcDialog mWifiToNfcDialog;
 142
 143     private ProgressBar mProgressHeader;
 144
 145     // this boolean extra specifies whether to disable the Next button when not connected. Used by
 146     // account creation outside of setup wizard.
 147     private static final String EXTRA_ENABLE_NEXT_ON_CONNECT = "wifi_enable_next_on_connect";
 148     // This string extra specifies a network to open the connect dialog on, so the user can enter
 149     // network credentials.  This is used by quick settings for secured networks, among other
 150     // things.
 151     public static final String EXTRA_START_CONNECT_SSID = "wifi_start_connect_ssid";
 152
 153     // should Next button only be enabled when we have a connection?
 154     private boolean mEnableNextOnConnection;
 155
 156     // Save the dialog details
 157     private int mDialogMode;
 158     private AccessPoint mDlgAccessPoint;
 159     private Bundle mAccessPointSavedState;
 160     private Bundle mWifiNfcDialogSavedState;
 161
 162     private WifiTracker mWifiTracker;
 163     private String mOpenSsid;
 164
 165     private HandlerThread mBgThread;
 166
 167     private AccessPointPreference.UserBadgeCache mUserBadgeCache;
 168
 169     private PreferenceCategory mConnectedAccessPointPreferenceCategory;
 170     private PreferenceCategory mAccessPointsPreferenceCategory;
 171     private PreferenceCategory mAdditionalSettingsPreferenceCategory;
 172     private Preference mAddPreference;
 173     private Preference mConfigureWifiSettingsPreference;
 174     private Preference mSavedNetworksPreference;
 175     private LinkablePreference mStatusMessagePreference;
 176
 177     // For Search
 178     private static final String DATA_KEY_REFERENCE = "main_toggle_wifi";
 179
 180     /* End of "used in Wifi Setup context" */
 181
 182     public WifiSettings() {
 183         super(DISALLOW_CONFIG_WIFI);
 184     }
 185
 186     @Override
 187     public void onViewCreated(View view, Bundle savedInstanceState) {
 188         super.onViewCreated(view, savedInstanceState);
 189         final Activity activity = getActivity();
 190         if (activity != null) {
 191             mProgressHeader = (ProgressBar) setPinnedHeaderView(R.layout.wifi_progress_header);
 192             setProgressBarVisible(false);
 193         }
 194     }
 195
 196     @Override
 197     public void onCreate(Bundle icicle) {
 198         super.onCreate(icicle);
 199
 200         // TODO(b/37429702): Add animations and preference comparator back after initial screen is
 201         // loaded (ODR).
 202         setAnimationAllowed(false);
 203
 204         addPreferencesFromResource(R.xml.wifi_settings);
 205
 206         mConnectedAccessPointPreferenceCategory =
 207                 (PreferenceCategory) findPreference(PREF_KEY_CONNECTED_ACCESS_POINTS);
 208         mAccessPointsPreferenceCategory =
 209                 (PreferenceCategory) findPreference(PREF_KEY_ACCESS_POINTS);
 210         mAdditionalSettingsPreferenceCategory =
 211                 (PreferenceCategory) findPreference(PREF_KEY_ADDITIONAL_SETTINGS);
 212         mConfigureWifiSettingsPreference = findPreference(PREF_KEY_CONFIGURE_WIFI_SETTINGS);
 213         mSavedNetworksPreference = findPreference(PREF_KEY_SAVED_NETWORKS);
 214
 215         Context prefContext = getPrefContext();
 216         mAddPreference = new Preference(prefContext);
 217         mAddPreference.setIcon(R.drawable.ic_menu_add_inset);
 218         mAddPreference.setTitle(R.string.wifi_add_network);
 219         mStatusMessagePreference = new LinkablePreference(prefContext);
 220
 221         mUserBadgeCache = new AccessPointPreference.UserBadgeCache(getPackageManager());
 222
 223         mIsRestricted = isUiRestricted();
 224
 225         mBgThread = new HandlerThread(TAG, Process.THREAD_PRIORITY_BACKGROUND);
 226         mBgThread.start();
 227     }
 228
 229     @Override
 230     public void onDestroy() {
 231         mBgThread.quit();
 232         super.onDestroy();
 233     }
 234
 235     @Override
 236     public void onActivityCreated(Bundle savedInstanceState) {
 237         super.onActivityCreated(savedInstanceState);
 238
 239         mWifiTracker = WifiTrackerFactory.create(
 240                 getActivity(), this, mBgThread.getLooper(), true, true, false);
 241         mWifiManager = mWifiTracker.getManager();
 242
 243         mConnectListener = new WifiManager.ActionListener() {
 244                                    @Override
 245                                    public void onSuccess() {
 246                                    }
 247                                    @Override
 248                                    public void onFailure(int reason) {
 249                                        Activity activity = getActivity();
 250                                        if (activity != null) {
 251                                            Toast.makeText(activity,
 252                                                 R.string.wifi_failed_connect_message,
 253                                                 Toast.LENGTH_SHORT).show();
 254                                        }
 255                                    }
 256                                };
 257
 258         mSaveListener = new WifiManager.ActionListener() {
 259                                 @Override
 260                                 public void onSuccess() {
 261                                 }
 262                                 @Override
 263                                 public void onFailure(int reason) {
 264                                     Activity activity = getActivity();
 265                                     if (activity != null) {
 266                                         Toast.makeText(activity,
 267                                             R.string.wifi_failed_save_message,
 268                                             Toast.LENGTH_SHORT).show();
 269                                     }
 270                                 }
 271                             };
 272
 273         mForgetListener = new WifiManager.ActionListener() {
 274                                    @Override
 275                                    public void onSuccess() {
 276                                    }
 277                                    @Override
 278                                    public void onFailure(int reason) {
 279                                        Activity activity = getActivity();
 280                                        if (activity != null) {
 281                                            Toast.makeText(activity,
 282                                                R.string.wifi_failed_forget_message,
 283                                                Toast.LENGTH_SHORT).show();
 284                                        }
 285                                    }
 286                                };
 287
 288         if (savedInstanceState != null) {
 289             mDialogMode = savedInstanceState.getInt(SAVE_DIALOG_MODE);
 290             if (savedInstanceState.containsKey(SAVE_DIALOG_ACCESS_POINT_STATE)) {
 291                 mAccessPointSavedState =
 292                     savedInstanceState.getBundle(SAVE_DIALOG_ACCESS_POINT_STATE);
 293             }
 294
 295             if (savedInstanceState.containsKey(SAVED_WIFI_NFC_DIALOG_STATE)) {
 296                 mWifiNfcDialogSavedState =
 297                     savedInstanceState.getBundle(SAVED_WIFI_NFC_DIALOG_STATE);
 298             }
 299         }
 300
 301         // if we're supposed to enable/disable the Next button based on our current connection
 302         // state, start it off in the right state
 303         Intent intent = getActivity().getIntent();
 304         mEnableNextOnConnection = intent.getBooleanExtra(EXTRA_ENABLE_NEXT_ON_CONNECT, false);
 305
 306         if (mEnableNextOnConnection) {
 307             if (hasNextButton()) {
 308                 final ConnectivityManager connectivity = (ConnectivityManager)
 309                         getActivity().getSystemService(Context.CONNECTIVITY_SERVICE);
 310                 if (connectivity != null) {
 311                     NetworkInfo info = connectivity.getNetworkInfo(
 312                             ConnectivityManager.TYPE_WIFI);
 313                     changeNextButtonState(info.isConnected());
 314                 }
 315             }
 316         }
 317
 318         registerForContextMenu(getListView());
 319         setHasOptionsMenu(true);
 320
 321         if (intent.hasExtra(EXTRA_START_CONNECT_SSID)) {
 322             mOpenSsid = intent.getStringExtra(EXTRA_START_CONNECT_SSID);
 323         }
 324     }
 325
 326     @Override
 327     public void onDestroyView() {
 328         super.onDestroyView();
 329
 330         if (mWifiEnabler != null) {
 331             mWifiEnabler.teardownSwitchController();
 332         }
 333     }
 334
 335     @Override
 336     public void onStart() {
 337         super.onStart();
 338
 339         // On/off switch is hidden for Setup Wizard (returns null)
 340         mWifiEnabler = createWifiEnabler();
 341
 342         mWifiTracker.startTracking();
 343
 344         if (mIsRestricted) {
 345             if (!isUiRestrictedByOnlyAdmin()) {
 346                 getEmptyTextView().setText(R.string.wifi_empty_list_user_restricted);
 347             }
 348             getPreferenceScreen().removeAll();
 349             return;
 350         }
 351
 352         onWifiStateChanged(mWifiManager.getWifiState());
 353     }
 354
 355     /**
 356      * Only update the AP list if there are not any APs currently shown.
 357      *
 358      * <p>Thus forceUpdate will only be called during cold start or when toggling between wifi on
 359      * and off. In other use cases, the previous APs will remain until the next update is received
 360      * from {@link WifiTracker}.
 361      */
 362     private void conditionallyForceUpdateAPs() {
 363         if (mAccessPointsPreferenceCategory.getPreferenceCount() > 0
 364                 && mAccessPointsPreferenceCategory.getPreference(0) instanceof
 365                         AccessPointPreference) {
 366             // Make sure we don't update due to callbacks initiated by sticky broadcasts in
 367             // WifiTracker.
 368             Log.d(TAG, "Did not force update APs due to existing APs displayed");
 369             getView().removeCallbacks(mUpdateAccessPointsRunnable);
 370             return;
 371         }
 372         setProgressBarVisible(true);
 373         mWifiTracker.forceUpdate();
 374         if (DEBUG) {
 375             Log.d(TAG, "WifiSettings force update APs: " + mWifiTracker.getAccessPoints());
 376         }
 377         getView().removeCallbacks(mUpdateAccessPointsRunnable);
 378         updateAccessPointPreferences();
 379     }
 380
 381     /**
 382      * @return new WifiEnabler or null (as overridden by WifiSettingsForSetupWizard)
 383      */
 384     private WifiEnabler createWifiEnabler() {
 385         final SettingsActivity activity = (SettingsActivity) getActivity();
 386         return new WifiEnabler(activity, new SwitchBarController(activity.getSwitchBar()),
 387             mMetricsFeatureProvider);
 388     }
 389
 390     @Override
 391     public void onResume() {
 392         final Activity activity = getActivity();
 393         super.onResume();
 394         if (mWifiEnabler != null) {
 395             mWifiEnabler.resume(activity);
 396         }
 397     }
 398
 399     @Override
 400     public void onPause() {
 401         super.onPause();
 402         if (mWifiEnabler != null) {
 403             mWifiEnabler.pause();
 404         }
 405     }
 406
 407     @Override
 408     public void onStop() {
 409         mWifiTracker.stopTracking();
 410         getView().removeCallbacks(mUpdateAccessPointsRunnable);
 411         getView().removeCallbacks(mHideProgressBarRunnable);
 412         super.onStop();
 413     }
 414
 415     @Override
 416     public int getMetricsCategory() {
 417         return MetricsEvent.WIFI;
 418     }
 419
 420     @Override
 421     public void onSaveInstanceState(Bundle outState) {
 422         super.onSaveInstanceState(outState);
 423
 424         // If the dialog is showing, save its state.
 425         if (mDialog != null && mDialog.isShowing()) {
 426             outState.putInt(SAVE_DIALOG_MODE, mDialogMode);
 427             if (mDlgAccessPoint != null) {
 428                 mAccessPointSavedState = new Bundle();
 429                 mDlgAccessPoint.saveWifiState(mAccessPointSavedState);
 430                 outState.putBundle(SAVE_DIALOG_ACCESS_POINT_STATE, mAccessPointSavedState);
 431             }
 432         }
 433
 434         if (mWifiToNfcDialog != null && mWifiToNfcDialog.isShowing()) {
 435             Bundle savedState = new Bundle();
 436             mWifiToNfcDialog.saveState(savedState);
 437             outState.putBundle(SAVED_WIFI_NFC_DIALOG_STATE, savedState);
 438         }
 439     }
 440
 441     @Override
 442     public boolean onOptionsItemSelected(MenuItem item) {
 443         // If the user is not allowed to configure wifi, do not handle menu selections.
 444         if (mIsRestricted) {
 445             return false;
 446         }
 447
 448         switch (item.getItemId()) {
 449             case MENU_ID_WPS_PBC:
 450                 showDialog(WPS_PBC_DIALOG_ID);
 451                 return true;
 452                 /*
 453             case MENU_ID_P2P:
 454                 if (getActivity() instanceof SettingsActivity) {
 455                     ((SettingsActivity) getActivity()).startPreferencePanel(
 456                             WifiP2pSettings.class.getCanonicalName(),
 457                             null,
 458                             R.string.wifi_p2p_settings_title, null,
 459                             this, 0);
 460                 } else {
 461                     startFragment(this, WifiP2pSettings.class.getCanonicalName(),
 462                             R.string.wifi_p2p_settings_title, -1, null);
 463                 }
 464                 return true;
 465                 */
 466             case MENU_ID_WPS_PIN:
 467                 showDialog(WPS_PIN_DIALOG_ID);
 468                 return true;
 469         }
 470         return super.onOptionsItemSelected(item);
 471     }
 472
 473     @Override
 474     public void onCreateContextMenu(ContextMenu menu, View view, ContextMenuInfo info) {
 475             Preference preference = (Preference) view.getTag();
 476
 477             if (preference instanceof LongPressAccessPointPreference) {
 478                 mSelectedAccessPoint =
 479                         ((LongPressAccessPointPreference) preference).getAccessPoint();
 480                 menu.setHeaderTitle(mSelectedAccessPoint.getSsid());
 481                 if (mSelectedAccessPoint.isConnectable()) {
 482                     menu.add(Menu.NONE, MENU_ID_CONNECT, 0, R.string.wifi_menu_connect);
 483                 }
 484
 485                 WifiConfiguration config = mSelectedAccessPoint.getConfig();
 486                 // Some configs are ineditable
 487                 if (isEditabilityLockedDown(getActivity(), config)) {
 488                     return;
 489                 }
 490
 491                 if (mSelectedAccessPoint.isSaved() || mSelectedAccessPoint.isEphemeral()) {
 492                     // Allow forgetting a network if either the network is saved or ephemerally
 493                     // connected. (In the latter case, "forget" blacklists the network so it won't
 494                     // be used again, ephemerally).
 495                     menu.add(Menu.NONE, MENU_ID_FORGET, 0, R.string.wifi_menu_forget);
 496                 }
 497                 if (mSelectedAccessPoint.isSaved()) {
 498                     menu.add(Menu.NONE, MENU_ID_MODIFY, 0, R.string.wifi_menu_modify);
 499                     NfcAdapter nfcAdapter = NfcAdapter.getDefaultAdapter(getActivity());
 500                     if (nfcAdapter != null && nfcAdapter.isEnabled() &&
 501                             mSelectedAccessPoint.getSecurity() != AccessPoint.SECURITY_NONE) {
 502                         // Only allow writing of NFC tags for password-protected networks.
 503                         menu.add(Menu.NONE, MENU_ID_WRITE_NFC, 0, R.string.wifi_menu_write_to_nfc);
 504                     }
 505                 }
 506             }
 507     }
 508
 509     @Override
 510     public boolean onContextItemSelected(MenuItem item) {
 511         if (mSelectedAccessPoint == null) {
 512             return super.onContextItemSelected(item);
 513         }
 514         switch (item.getItemId()) {
 515             case MENU_ID_CONNECT: {
 516                 boolean isSavedNetwork = mSelectedAccessPoint.isSaved();
 517                 if (isSavedNetwork) {
 518                     connect(mSelectedAccessPoint.getConfig(), isSavedNetwork);
 519                 } else if (mSelectedAccessPoint.getSecurity() == AccessPoint.SECURITY_NONE) {
 520                     /** Bypass dialog for unsecured networks */
 521                     mSelectedAccessPoint.generateOpenNetworkConfig();
 522                     connect(mSelectedAccessPoint.getConfig(), isSavedNetwork);
 523                 } else {
 524                     showDialog(mSelectedAccessPoint, WifiConfigUiBase.MODE_CONNECT);
 525                 }
 526                 return true;
 527             }
 528             case MENU_ID_FORGET: {
 529                 forget();
 530                 return true;
 531             }
 532             case MENU_ID_MODIFY: {
 533                 showDialog(mSelectedAccessPoint, WifiConfigUiBase.MODE_MODIFY);
 534                 return true;
 535             }
 536             case MENU_ID_WRITE_NFC:
 537                 showDialog(WRITE_NFC_DIALOG_ID);
 538                 return true;
 539
 540         }
 541         return super.onContextItemSelected(item);
 542     }
 543
 544     @Override
 545     public boolean onPreferenceTreeClick(Preference preference) {
 546         // If the preference has a fragment set, open that
 547         if (preference.getFragment() != null) {
 548             preference.setOnPreferenceClickListener(null);
 549             return super.onPreferenceTreeClick(preference);
 550         }
 551
 552         if (preference instanceof LongPressAccessPointPreference) {
 553             mSelectedAccessPoint = ((LongPressAccessPointPreference) preference).getAccessPoint();
 554             if (mSelectedAccessPoint == null) {
 555                 return false;
 556             }
 557             if (mSelectedAccessPoint.isActive()) {
 558                 return super.onPreferenceTreeClick(preference);
 559             }
 560             /**
 561              * Bypass dialog and connect to unsecured networks, or previously connected saved
 562              * networks, or Passpoint provided networks.
 563              */
 564             WifiConfiguration config = mSelectedAccessPoint.getConfig();
 565             if (mSelectedAccessPoint.getSecurity() == AccessPoint.SECURITY_NONE) {
 566                 mSelectedAccessPoint.generateOpenNetworkConfig();
 567                 connect(mSelectedAccessPoint.getConfig(), mSelectedAccessPoint.isSaved());
 568             } else if (mSelectedAccessPoint.isSaved() && config != null
 569                     && config.getNetworkSelectionStatus() != null
 570                     && config.getNetworkSelectionStatus().getHasEverConnected()) {
 571                 connect(config, true /* isSavedNetwork */);
 572             } else if (mSelectedAccessPoint.isPasspoint()) {
 573                 // Access point provided by an installed Passpoint provider, connect using
 574                 // the associated config.
 575                 connect(config, true /* isSavedNetwork */);
 576             } else {
 577                 showDialog(mSelectedAccessPoint, WifiConfigUiBase.MODE_CONNECT);
 578             }
 579         } else if (preference == mAddPreference) {
 580             onAddNetworkPressed();
 581         } else {
 582             return super.onPreferenceTreeClick(preference);
 583         }
 584         return true;
 585     }
 586
 587     private void showDialog(AccessPoint accessPoint, int dialogMode) {
 588         if (accessPoint != null) {
 589             WifiConfiguration config = accessPoint.getConfig();
 590             if (isEditabilityLockedDown(getActivity(), config) && accessPoint.isActive()) {
 591                 RestrictedLockUtils.sendShowAdminSupportDetailsIntent(getActivity(),
 592                         RestrictedLockUtils.getDeviceOwner(getActivity()));
 593                 return;
 594             }
 595         }
 596
 597         if (mDialog != null) {
 598             removeDialog(WIFI_DIALOG_ID);
 599             mDialog = null;
 600         }
 601
 602         // Save the access point and edit mode
 603         mDlgAccessPoint = accessPoint;
 604         mDialogMode = dialogMode;
 605
 606         showDialog(WIFI_DIALOG_ID);
 607     }
 608
 609     @Override
 610     public Dialog onCreateDialog(int dialogId) {
 611         switch (dialogId) {
 612             case WIFI_DIALOG_ID:
 613                 AccessPoint ap = mDlgAccessPoint; // For manual launch
 614                 if (ap == null) { // For re-launch from saved state
 615                     if (mAccessPointSavedState != null) {
 616                         ap = new AccessPoint(getActivity(), mAccessPointSavedState);
 617                         // For repeated orientation changes
 618                         mDlgAccessPoint = ap;
 619                         // Reset the saved access point data
 620                         mAccessPointSavedState = null;
 621                     }
 622                 }
 623                 // If it's null, fine, it's for Add Network
 624                 mSelectedAccessPoint = ap;
 625                 mDialog = new WifiDialog(getActivity(), this, ap, mDialogMode,
 626                         /* no hide submit/connect */ false);
 627                 return mDialog;
 628             case WPS_PBC_DIALOG_ID:
 629                 return new WpsDialog(getActivity(), WpsInfo.PBC);
 630             case WPS_PIN_DIALOG_ID:
 631                 return new WpsDialog(getActivity(), WpsInfo.DISPLAY);
 632             case WRITE_NFC_DIALOG_ID:
 633                 if (mSelectedAccessPoint != null) {
 634                     mWifiToNfcDialog = new WriteWifiConfigToNfcDialog(
 635                             getActivity(),
 636                             mSelectedAccessPoint.getSecurity(),
 637                             new WifiManagerWrapper(mWifiManager));
 638                 } else if (mWifiNfcDialogSavedState != null) {
 639                     mWifiToNfcDialog = new WriteWifiConfigToNfcDialog(getActivity(),
 640                             mWifiNfcDialogSavedState, new WifiManagerWrapper(mWifiManager));
 641                 }
 642
 643                 return mWifiToNfcDialog;
 644         }
 645         return super.onCreateDialog(dialogId);
 646     }
 647
 648     @Override
 649     public int getDialogMetricsCategory(int dialogId) {
 650         switch (dialogId) {
 651             case WIFI_DIALOG_ID:
 652                 return MetricsEvent.DIALOG_WIFI_AP_EDIT;
 653             case WPS_PBC_DIALOG_ID:
 654                 return MetricsEvent.DIALOG_WIFI_PBC;
 655             case WPS_PIN_DIALOG_ID:
 656                 return MetricsEvent.DIALOG_WIFI_PIN;
 657             case WRITE_NFC_DIALOG_ID:
 658                 return MetricsEvent.DIALOG_WIFI_WRITE_NFC;
 659             default:
 660                 return 0;
 661         }
 662     }
 663
 664     /**
 665      * Called to indicate the list of AccessPoints has been updated and
 666      * getAccessPoints should be called to get the latest information.
 667      */
 668     @Override
 669     public void onAccessPointsChanged() {
 670         Log.d(TAG, "onAccessPointsChanged (WifiTracker) callback initiated");
 671         updateAccessPointsDelayed();
 672     }
 673
 674     /**
 675      * Updates access points from {@link WifiManager#getScanResults()}. Adds a delay to have
 676      * progress bar displayed before starting to modify APs.
 677      */
 678     private void updateAccessPointsDelayed() {
 679         // Safeguard from some delayed event handling
 680         if (getActivity() != null && !mIsRestricted && mWifiManager.isWifiEnabled()) {
 681             setProgressBarVisible(true);
 682             getView().postDelayed(mUpdateAccessPointsRunnable, 300 /* delay milliseconds */);
 683         }
 684     }
 685
 686     /** Called when the state of Wifi has changed. */
 687     @Override
 688     public void onWifiStateChanged(int state) {
 689         if (mIsRestricted) {
 690             return;
 691         }
 692
 693         final int wifiState = mWifiManager.getWifiState();
 694         switch (wifiState) {
 695             case WifiManager.WIFI_STATE_ENABLED:
 696                 conditionallyForceUpdateAPs();
 697                 break;
 698
 699             case WifiManager.WIFI_STATE_ENABLING:
 700                 removeConnectedAccessPointPreference();
 701                 mAccessPointsPreferenceCategory.removeAll();
 702                 addMessagePreference(R.string.wifi_starting);
 703                 setProgressBarVisible(true);
 704                 break;
 705
 706             case WifiManager.WIFI_STATE_DISABLING:
 707                 removeConnectedAccessPointPreference();
 708                 mAccessPointsPreferenceCategory.removeAll();
 709                 addMessagePreference(R.string.wifi_stopping);
 710                 break;
 711
 712             case WifiManager.WIFI_STATE_DISABLED:
 713                 setOffMessage();
 714                 setAdditionalSettingsSummaries();
 715                 setProgressBarVisible(false);
 716                 break;
 717         }
 718     }
 719
 720     /**
 721      * Called when the connection state of wifi has changed and isConnected
 722      * should be called to get the updated state.
 723      */
 724     @Override
 725     public void onConnectedChanged() {
 726         updateAccessPointsDelayed();
 727         changeNextButtonState(mWifiTracker.isConnected());
 728     }
 729
 730     /** Helper method to return whether an AccessPoint is disabled due to a wrong password */
 731     private static boolean isDisabledByWrongPassword(AccessPoint accessPoint) {
 732         WifiConfiguration config = accessPoint.getConfig();
 733         if (config == null) {
 734             return false;
 735         }
 736         WifiConfiguration.NetworkSelectionStatus networkStatus =
 737                 config.getNetworkSelectionStatus();
 738         if (networkStatus == null || networkStatus.isNetworkEnabled()) {
 739             return false;
 740         }
 741         int reason = networkStatus.getNetworkSelectionDisableReason();
 742         return WifiConfiguration.NetworkSelectionStatus.DISABLED_BY_WRONG_PASSWORD == reason;
 743     }
 744
 745     private void updateAccessPointPreferences() {
 746         // in case state has changed
 747         if (!mWifiManager.isWifiEnabled()) {
 748             return;
 749         }
 750         // AccessPoints are sorted by the WifiTracker
 751         final List<AccessPoint> accessPoints = mWifiTracker.getAccessPoints();
 752         if (DEBUG) {
 753             Log.d(TAG, "updateAccessPoints called for: " + accessPoints);
 754         }
 755
 756         boolean hasAvailableAccessPoints = false;
 757         mAccessPointsPreferenceCategory.removePreference(mStatusMessagePreference);
 758         cacheRemoveAllPrefs(mAccessPointsPreferenceCategory);
 759
 760         int index =
 761                 configureConnectedAccessPointPreferenceCategory(accessPoints) ? 1 : 0;
 762         int numAccessPoints = accessPoints.size();
 763         for (; index < numAccessPoints; index++) {
 764             AccessPoint accessPoint = accessPoints.get(index);
 765             // Ignore access points that are out of range.
 766             if (accessPoint.isReachable()) {
 767                 String key = AccessPointPreference.generatePreferenceKey(accessPoint);
 768                 hasAvailableAccessPoints = true;
 769                 LongPressAccessPointPreference pref =
 770                         (LongPressAccessPointPreference) getCachedPreference(key);
 771                 if (pref != null) {
 772                     pref.setOrder(index);
 773                     continue;
 774                 }
 775                 LongPressAccessPointPreference preference =
 776                         createLongPressActionPointPreference(accessPoint);
 777                 preference.setKey(key);
 778                 preference.setOrder(index);
 779                 if (mOpenSsid != null && mOpenSsid.equals(accessPoint.getSsidStr())
 780                         && accessPoint.getSecurity() != AccessPoint.SECURITY_NONE) {
 781                     if (!accessPoint.isSaved() || isDisabledByWrongPassword(accessPoint)) {
 782                         onPreferenceTreeClick(preference);
 783                         mOpenSsid = null;
 784                     }
 785                 }
 786                 mAccessPointsPreferenceCategory.addPreference(preference);
 787                 accessPoint.setListener(WifiSettings.this);
 788                 preference.refresh();
 789             }
 790         }
 791         removeCachedPrefs(mAccessPointsPreferenceCategory);
 792         mAddPreference.setOrder(index);
 793         mAccessPointsPreferenceCategory.addPreference(mAddPreference);
 794         setAdditionalSettingsSummaries();
 795
 796         if (!hasAvailableAccessPoints) {
 797             setProgressBarVisible(true);
 798             Preference pref = new Preference(getPrefContext());
 799             pref.setSelectable(false);
 800             pref.setSummary(R.string.wifi_empty_list_wifi_on);
 801             pref.setOrder(index++);
 802             pref.setKey(PREF_KEY_EMPTY_WIFI_LIST);
 803             mAccessPointsPreferenceCategory.addPreference(pref);
 804         } else {
 805             // Continuing showing progress bar for an additional delay to overlap with animation
 806             getView().postDelayed(mHideProgressBarRunnable, 1700 /* delay millis */);
 807         }
 808     }
 809
 810     @NonNull
 811     private LongPressAccessPointPreference createLongPressActionPointPreference(
 812             AccessPoint accessPoint) {
 813         return new LongPressAccessPointPreference(accessPoint, getPrefContext(), mUserBadgeCache,
 814                 false, R.drawable.ic_wifi_signal_0, this);
 815     }
 816
 817     /**
 818      * Configure the ConnectedAccessPointPreferenceCategory and return true if the Category was
 819      * shown.
 820      */
 821     private boolean configureConnectedAccessPointPreferenceCategory(
 822             List<AccessPoint> accessPoints) {
 823         if (accessPoints.size() == 0) {
 824             removeConnectedAccessPointPreference();
 825             return false;
 826         }
 827
 828         AccessPoint connectedAp = accessPoints.get(0);
 829         if (!connectedAp.isActive()) {
 830             removeConnectedAccessPointPreference();
 831             return false;
 832         }
 833
 834         // Is the preference category empty?
 835         if (mConnectedAccessPointPreferenceCategory.getPreferenceCount() == 0) {
 836             addConnectedAccessPointPreference(connectedAp);
 837             return true;
 838         }
 839
 840         // Is the previous currently connected SSID different from the new one?
 841         if (!((AccessPointPreference)
 842                 mConnectedAccessPointPreferenceCategory.getPreference(0))
 843                         .getAccessPoint().getSsidStr().equals(
 844                                 connectedAp.getSsidStr())) {
 845             removeConnectedAccessPointPreference();
 846             addConnectedAccessPointPreference(connectedAp);
 847             return true;
 848         }
 849
 850         // Else same AP is connected, simply refresh the connected access point preference
 851         // (first and only access point in this category).
 852         ((LongPressAccessPointPreference) mConnectedAccessPointPreferenceCategory.getPreference(0))
 853                 .refresh();
 854         return true;
 855     }
 856
 857     /**
 858      * Creates a Preference for the given {@link AccessPoint} and adds it to the
 859      * {@link #mConnectedAccessPointPreferenceCategory}.
 860      */
 861     private void addConnectedAccessPointPreference(AccessPoint connectedAp) {
 862         String key = connectedAp.getBssid();
 863         LongPressAccessPointPreference pref = (LongPressAccessPointPreference)
 864                 getCachedPreference(key);
 865         if (pref == null) {
 866             pref = createLongPressActionPointPreference(connectedAp);
 867         }
 868
 869         // Save the state of the current access point in the bundle so that we can restore it
 870         // in the Wifi Network Details Fragment
 871         pref.getAccessPoint().saveWifiState(pref.getExtras());
 872         pref.setFragment(WifiNetworkDetailsFragment.class.getName());
 873         pref.refresh();
 874
 875         mConnectedAccessPointPreferenceCategory.addPreference(pref);
 876         mConnectedAccessPointPreferenceCategory.setVisible(true);
 877     }
 878
 879     /** Removes all preferences and hide the {@link #mConnectedAccessPointPreferenceCategory}. */
 880     private void removeConnectedAccessPointPreference() {
 881         mConnectedAccessPointPreferenceCategory.removeAll();
 882         mConnectedAccessPointPreferenceCategory.setVisible(false);
 883     }
 884
 885     private void setAdditionalSettingsSummaries() {
 886         mAdditionalSettingsPreferenceCategory.addPreference(mConfigureWifiSettingsPreference);
 887         final int defaultWakeupAvailable = getResources().getInteger(
 888                 com.android.internal.R.integer.config_wifi_wakeup_available);
 889         boolean wifiWakeupAvailable = Settings.Global.getInt(
 890                 getContentResolver(), Settings.Global.WIFI_WAKEUP_AVAILABLE, defaultWakeupAvailable)
 891                 == 1;
 892         if (wifiWakeupAvailable) {
 893             boolean wifiWakeupEnabled = Settings.Global.getInt(
 894                     getContentResolver(), Settings.Global.WIFI_WAKEUP_ENABLED, 0) == 1;
 895             mConfigureWifiSettingsPreference.setSummary(getString(wifiWakeupEnabled
 896                     ? R.string.wifi_configure_settings_preference_summary_wakeup_on
 897                     : R.string.wifi_configure_settings_preference_summary_wakeup_off));
 898         }
 899         int numSavedNetworks = mWifiTracker.getNumSavedNetworks();
 900         if (numSavedNetworks > 0) {
 901             mAdditionalSettingsPreferenceCategory.addPreference(mSavedNetworksPreference);
 902             mSavedNetworksPreference.setSummary(
 903                     getResources().getQuantityString(R.plurals.wifi_saved_access_points_summary,
 904                             numSavedNetworks, numSavedNetworks));
 905         } else {
 906             mAdditionalSettingsPreferenceCategory.removePreference(mSavedNetworksPreference);
 907         }
 908     }
 909
 910     private void setOffMessage() {
 911         final CharSequence title = getText(R.string.wifi_empty_list_wifi_off);
 912         // Don't use WifiManager.isScanAlwaysAvailable() to check the Wi-Fi scanning mode. Instead,
 913         // read the system settings directly. Because when the device is in Airplane mode, even if
 914         // Wi-Fi scanning mode is on, WifiManager.isScanAlwaysAvailable() still returns "off".
 915         final boolean wifiScanningMode = Settings.Global.getInt(getActivity().getContentResolver(),
 916                 Settings.Global.WIFI_SCAN_ALWAYS_AVAILABLE, 0) == 1;
 917         final CharSequence description = wifiScanningMode ? getText(R.string.wifi_scan_notify_text)
 918                 : getText(R.string.wifi_scan_notify_text_scanning_off);
 919         final LinkifyUtils.OnClickListener clickListener = new LinkifyUtils.OnClickListener() {
 920             @Override
 921             public void onClick() {
 922                 final SettingsActivity activity = (SettingsActivity) getActivity();
 923                 activity.startPreferencePanel(WifiSettings.this,
 924                         ScanningSettings.class.getName(),
 925                         null, R.string.location_scanning_screen_title, null, null, 0);
 926             }
 927         };
 928         mStatusMessagePreference.setText(title, description, clickListener);
 929         removeConnectedAccessPointPreference();
 930         mAccessPointsPreferenceCategory.removeAll();
 931         mAccessPointsPreferenceCategory.addPreference(mStatusMessagePreference);
 932     }
 933
 934     private void addMessagePreference(int messageId) {
 935         mStatusMessagePreference.setTitle(messageId);
 936         removeConnectedAccessPointPreference();
 937         mAccessPointsPreferenceCategory.removeAll();
 938         mAccessPointsPreferenceCategory.addPreference(mStatusMessagePreference);
 939     }
 940
 941     protected void setProgressBarVisible(boolean visible) {
 942         if (mProgressHeader != null) {
 943             mProgressHeader.setVisibility(visible ? View.VISIBLE : View.INVISIBLE);
 944         }
 945     }
 946
 947     /**
 948      * Renames/replaces "Next" button when appropriate. "Next" button usually exists in
 949      * Wifi setup screens, not in usual wifi settings screen.
 950      *
 951      * @param enabled true when the device is connected to a wifi network.
 952      */
 953     private void changeNextButtonState(boolean enabled) {
 954         if (mEnableNextOnConnection && hasNextButton()) {
 955             getNextButton().setEnabled(enabled);
 956         }
 957     }
 958
 959     @Override
 960     public void onForget(WifiDialog dialog) {
 961         forget();
 962     }
 963
 964     @Override
 965     public void onSubmit(WifiDialog dialog) {
 966         if (mDialog != null) {
 967             submit(mDialog.getController());
 968         }
 969     }
 970
 971     /* package */ void submit(WifiConfigController configController) {
 972
 973         final WifiConfiguration config = configController.getConfig();
 974
 975         if (config == null) {
 976             if (mSelectedAccessPoint != null
 977                     && mSelectedAccessPoint.isSaved()) {
 978                 connect(mSelectedAccessPoint.getConfig(), true /* isSavedNetwork */);
 979             }
 980         } else if (configController.getMode() == WifiConfigUiBase.MODE_MODIFY) {
 981             mWifiManager.save(config, mSaveListener);
 982         } else {
 983             mWifiManager.save(config, mSaveListener);
 984             if (mSelectedAccessPoint != null) { // Not an "Add network"
 985                 connect(config, false /* isSavedNetwork */);
 986             }
 987         }
 988
 989         mWifiTracker.resumeScanning();
 990     }
 991
 992     /* package */ void forget() {
 993         mMetricsFeatureProvider.action(getActivity(), MetricsEvent.ACTION_WIFI_FORGET);
 994         if (!mSelectedAccessPoint.isSaved()) {
 995             if (mSelectedAccessPoint.getNetworkInfo() != null &&
 996                     mSelectedAccessPoint.getNetworkInfo().getState() != State.DISCONNECTED) {
 997                 // Network is active but has no network ID - must be ephemeral.
 998                 mWifiManager.disableEphemeralNetwork(
 999                         AccessPoint.convertToQuotedString(mSelectedAccessPoint.getSsidStr()));
1000             } else {
1001                 // Should not happen, but a monkey seems to trigger it
1002                 Log.e(TAG, "Failed to forget invalid network " + mSelectedAccessPoint.getConfig());
1003                 return;
1004             }
1005         } else if (mSelectedAccessPoint.getConfig().isPasspoint()) {
1006             mWifiManager.removePasspointConfiguration(mSelectedAccessPoint.getConfig().FQDN);
1007         } else {
1008             mWifiManager.forget(mSelectedAccessPoint.getConfig().networkId, mForgetListener);
1009         }
1010
1011         mWifiTracker.resumeScanning();
1012
1013         // We need to rename/replace "Next" button in wifi setup context.
1014         changeNextButtonState(false);
1015     }
1016
1017     protected void connect(final WifiConfiguration config, boolean isSavedNetwork) {
1018         // Log subtype if configuration is a saved network.
1019         mMetricsFeatureProvider.action(getActivity(), MetricsEvent.ACTION_WIFI_CONNECT,
1020                 isSavedNetwork);
1021         mWifiManager.connect(config, mConnectListener);
1022         scrollToPreference(mConnectedAccessPointPreferenceCategory);
1023     }
1024
1025     protected void connect(final int networkId, boolean isSavedNetwork) {
1026         // Log subtype if configuration is a saved network.
1027         mMetricsFeatureProvider.action(getActivity(), MetricsEvent.ACTION_WIFI_CONNECT,
1028                 isSavedNetwork);
1029         mWifiManager.connect(networkId, mConnectListener);
1030     }
1031
1032     /**
1033      * Called when "add network" button is pressed.
1034      */
1035     /* package */ void onAddNetworkPressed() {
1036         mMetricsFeatureProvider.action(getActivity(), MetricsEvent.ACTION_WIFI_ADD_NETWORK);
1037         // No exact access point is selected.
1038         mSelectedAccessPoint = null;
1039         showDialog(null, WifiConfigUiBase.MODE_CONNECT);
1040     }
1041
1042     @Override
1043     protected int getHelpResource() {
1044         return R.string.help_url_wifi;
1045     }
1046
1047     @Override
1048     public void onAccessPointChanged(final AccessPoint accessPoint) {
1049         Log.d(TAG, "onAccessPointChanged (singular) callback initiated");
1050         View view = getView();
1051         if (view != null) {
1052             view.post(new Runnable() {
1053                 @Override
1054                 public void run() {
1055                     Object tag = accessPoint.getTag();
1056                     if (tag != null) {
1057                         ((LongPressAccessPointPreference) tag).refresh();
1058                     }
1059                 }
1060             });
1061         }
1062     }
1063
1064     @Override
1065     public void onLevelChanged(AccessPoint accessPoint) {
1066         ((LongPressAccessPointPreference) accessPoint.getTag()).onLevelChanged();
1067     }
1068
1069     public static final SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
1070         new BaseSearchIndexProvider() {
1071             @Override
1072             public List<SearchIndexableRaw> getRawDataToIndex(Context context, boolean enabled) {
1073                 final List<SearchIndexableRaw> result = new ArrayList<>();
1074                 final Resources res = context.getResources();
1075
1076                 // Add fragment title
1077                 SearchIndexableRaw data = new SearchIndexableRaw(context);
1078                 data.title = res.getString(R.string.wifi_settings);
1079                 data.screenTitle = res.getString(R.string.wifi_settings);
1080                 data.keywords = res.getString(R.string.keywords_wifi);
1081                 data.key = DATA_KEY_REFERENCE;
1082                 result.add(data);
1083
1084                 // Add saved Wi-Fi access points
1085                 final List<AccessPoint> accessPoints =
1086                         WifiTracker.getCurrentAccessPoints(context, true, false, false);
1087                 for (AccessPoint accessPoint : accessPoints) {
1088                     data = new SearchIndexableRaw(context);
1089                     data.title = accessPoint.getSsidStr();
1090                     data.screenTitle = res.getString(R.string.wifi_settings);
1091                     data.enabled = enabled;
1092                     result.add(data);
1093                 }
1094
1095                 return result;
1096             }
1097         };
1098
1099     /**
1100      * Returns true if the config is not editable through Settings.
1101      * @param context Context of caller
1102      * @param config The WiFi config.
1103      * @return true if the config is not editable through Settings.
1104      */
1105     static boolean isEditabilityLockedDown(Context context, WifiConfiguration config) {
1106         return !canModifyNetwork(context, config);
1107     }
1108
1109     /**
1110      * This method is a stripped version of WifiConfigStore.canModifyNetwork.
1111      * TODO: refactor to have only one method.
1112      * @param context Context of caller
1113      * @param config The WiFi config.
1114      * @return true if Settings can modify the config.
1115      */
1116     static boolean canModifyNetwork(Context context, WifiConfiguration config) {
1117         if (config == null) {
1118             return true;
1119         }
1120
1121         final DevicePolicyManager dpm = (DevicePolicyManager) context.getSystemService(
1122                 Context.DEVICE_POLICY_SERVICE);
1123
1124         // Check if device has DPM capability. If it has and dpm is still null, then we
1125         // treat this case with suspicion and bail out.
1126         final PackageManager pm = context.getPackageManager();
1127         if (pm.hasSystemFeature(PackageManager.FEATURE_DEVICE_ADMIN) && dpm == null) {
1128             return false;
1129         }
1130
1131         boolean isConfigEligibleForLockdown = false;
1132         if (dpm != null) {
1133             final ComponentName deviceOwner = dpm.getDeviceOwnerComponentOnAnyUser();
1134             if (deviceOwner != null) {
1135                 final int deviceOwnerUserId = dpm.getDeviceOwnerUserId();
1136                 try {
1137                     final int deviceOwnerUid = pm.getPackageUidAsUser(deviceOwner.getPackageName(),
1138                             deviceOwnerUserId);
1139                     isConfigEligibleForLockdown = deviceOwnerUid == config.creatorUid;
1140                 } catch (NameNotFoundException e) {
1141                     // don't care
1142                 }
1143             }
1144         }
1145         if (!isConfigEligibleForLockdown) {
1146             return true;
1147         }
1148
1149         final ContentResolver resolver = context.getContentResolver();
1150         final boolean isLockdownFeatureEnabled = Settings.Global.getInt(resolver,
1151                 Settings.Global.WIFI_DEVICE_OWNER_CONFIGS_LOCKDOWN, 0) != 0;
1152         return !isLockdownFeatureEnabled;
1153     }
1154
1155     private static class SummaryProvider
1156             implements SummaryLoader.SummaryProvider, OnSummaryChangeListener {
1157
1158         private final Context mContext;
1159         private final SummaryLoader mSummaryLoader;
1160
1161         @VisibleForTesting
1162         WifiSummaryUpdater mSummaryHelper;
1163
1164         public SummaryProvider(Context context, SummaryLoader summaryLoader) {
1165             mContext = context;
1166             mSummaryLoader = summaryLoader;
1167             mSummaryHelper = new WifiSummaryUpdater(mContext, this);
1168         }
1169
1170
1171         @Override
1172         public void setListening(boolean listening) {
1173             mSummaryHelper.register(listening);
1174         }
1175
1176         @Override
1177         public void onSummaryChanged(String summary) {
1178             mSummaryLoader.setSummary(this, summary);
1179         }
1180     }
1181
1182     public static final SummaryLoader.SummaryProviderFactory SUMMARY_PROVIDER_FACTORY
1183             = new SummaryLoader.SummaryProviderFactory() {
1184         @Override
1185         public SummaryLoader.SummaryProvider createSummaryProvider(Activity activity,
1186                                                                    SummaryLoader summaryLoader) {
1187             return new SummaryProvider(activity, summaryLoader);
1188         }
1189     };
1190 }