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