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