src/com/android/settings/wifi/WifiConfigController.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 android.content.Context;
  20 import android.content.res.Resources;
  21 import android.net.IpConfiguration;
  22 import android.net.IpConfiguration.IpAssignment;
  23 import android.net.IpConfiguration.ProxySettings;
  24 import android.net.LinkAddress;
  25 import android.net.NetworkInfo.DetailedState;
  26 import android.net.NetworkUtils;
  27 import android.net.ProxyInfo;
  28 import android.net.StaticIpConfiguration;
  29 import android.net.Uri;
  30 import android.net.wifi.WifiConfiguration;
  31 import android.net.wifi.WifiConfiguration.AuthAlgorithm;
  32 import android.net.wifi.WifiConfiguration.KeyMgmt;
  33 import android.net.wifi.WifiEnterpriseConfig;
  34 import android.net.wifi.WifiEnterpriseConfig.Eap;
  35 import android.net.wifi.WifiEnterpriseConfig.Phase2;
  36 import android.net.wifi.WifiInfo;
  37 import android.net.wifi.WifiManager;
  38 import android.os.UserManager;
  39 import android.security.Credentials;
  40 import android.security.KeyStore;
  41 import android.text.Editable;
  42 import android.text.InputType;
  43 import android.text.TextUtils;
  44 import android.text.TextWatcher;
  45 import android.util.Log;
  46 import android.view.KeyEvent;
  47 import android.view.View;
  48 import android.view.ViewGroup;
  49 import android.view.inputmethod.EditorInfo;
  50 import android.widget.AdapterView;
  51 import android.widget.ArrayAdapter;
  52 import android.widget.Button;
  53 import android.widget.CheckBox;
  54 import android.widget.CompoundButton;
  55 import android.widget.CompoundButton.OnCheckedChangeListener;
  56 import android.widget.EditText;
  57 import android.widget.ImageButton;
  58 import android.widget.ScrollView;
  59 import android.widget.Spinner;
  60 import android.widget.TextView;
  61
  62 import androidx.annotation.VisibleForTesting;
  63
  64 import com.android.settings.ProxySelector;
  65 import com.android.settings.R;
  66 import com.android.settings.wifi.details.WifiPrivacyPreferenceController;
  67 import com.android.settings.wifi.dpp.WifiDppUtils;
  68 import com.android.settingslib.Utils;
  69 import com.android.settingslib.utils.ThreadUtils;
  70 import com.android.settingslib.wifi.AccessPoint;
  71
  72 import java.net.Inet4Address;
  73 import java.net.InetAddress;
  74 import java.util.ArrayList;
  75 import java.util.Arrays;
  76 import java.util.Iterator;
  77
  78 /**
  79  * The class for allowing UIs like {@link WifiDialog} and {@link WifiConfigUiBase} to
  80  * share the logic for controlling buttons, text fields, etc.
  81  */
  82 public class WifiConfigController implements TextWatcher,
  83         AdapterView.OnItemSelectedListener, OnCheckedChangeListener,
  84         TextView.OnEditorActionListener, View.OnKeyListener {
  85     private static final String TAG = "WifiConfigController";
  86
  87     private static final String SYSTEM_CA_STORE_PATH = "/system/etc/security/cacerts";
  88
  89     private final WifiConfigUiBase mConfigUi;
  90     private final View mView;
  91     private final AccessPoint mAccessPoint;
  92
  93     /* This value comes from "wifi_ip_settings" resource array */
  94     private static final int DHCP = 0;
  95     private static final int STATIC_IP = 1;
  96
  97     /* Constants used for referring to the hidden state of a network. */
  98     public static final int HIDDEN_NETWORK = 1;
  99     public static final int NOT_HIDDEN_NETWORK = 0;
 100
 101     /* These values come from "wifi_proxy_settings" resource array */
 102     public static final int PROXY_NONE = 0;
 103     public static final int PROXY_STATIC = 1;
 104     public static final int PROXY_PAC = 2;
 105
 106     /* These values come from "wifi_eap_method" resource array */
 107     public static final int WIFI_EAP_METHOD_PEAP = 0;
 108     public static final int WIFI_EAP_METHOD_TLS  = 1;
 109     public static final int WIFI_EAP_METHOD_TTLS = 2;
 110     public static final int WIFI_EAP_METHOD_PWD  = 3;
 111     public static final int WIFI_EAP_METHOD_SIM  = 4;
 112     public static final int WIFI_EAP_METHOD_AKA  = 5;
 113     public static final int WIFI_EAP_METHOD_AKA_PRIME  = 6;
 114
 115     /* These values come from "wifi_peap_phase2_entries" resource array */
 116     public static final int WIFI_PEAP_PHASE2_NONE       = 0;
 117     public static final int WIFI_PEAP_PHASE2_MSCHAPV2   = 1;
 118     public static final int WIFI_PEAP_PHASE2_GTC        = 2;
 119     public static final int WIFI_PEAP_PHASE2_SIM        = 3;
 120     public static final int WIFI_PEAP_PHASE2_AKA        = 4;
 121     public static final int WIFI_PEAP_PHASE2_AKA_PRIME  = 5;
 122
 123
 124     /* Phase2 methods supported by PEAP are limited */
 125     private ArrayAdapter<String> mPhase2PeapAdapter;
 126     /* Full list of phase2 methods */
 127     private ArrayAdapter<String> mPhase2FullAdapter;
 128
 129     // e.g. AccessPoint.SECURITY_NONE
 130     @VisibleForTesting
 131     int mAccessPointSecurity;
 132     private TextView mPasswordView;
 133     private ImageButton mSsidScanButton;
 134     private ImageButton mPasswordScanButton;
 135
 136     private String mUnspecifiedCertString;
 137     private String mMultipleCertSetString;
 138     private String mUseSystemCertsString;
 139     private String mDoNotProvideEapUserCertString;
 140     private String mDoNotValidateEapServerString;
 141
 142     private ScrollView mDialogContainer;
 143     private Spinner mSecuritySpinner;
 144     private Spinner mEapMethodSpinner;
 145     private Spinner mEapCaCertSpinner;
 146     private TextView mEapDomainView;
 147     private Spinner mPhase2Spinner;
 148     // Associated with mPhase2Spinner, one of mPhase2FullAdapter or mPhase2PeapAdapter
 149     private ArrayAdapter<String> mPhase2Adapter;
 150     private Spinner mEapUserCertSpinner;
 151     private TextView mEapIdentityView;
 152     private TextView mEapAnonymousView;
 153
 154     private Spinner mIpSettingsSpinner;
 155     private TextView mIpAddressView;
 156     private TextView mGatewayView;
 157     private TextView mNetworkPrefixLengthView;
 158     private TextView mDns1View;
 159     private TextView mDns2View;
 160
 161     private Spinner mProxySettingsSpinner;
 162     private Spinner mMeteredSettingsSpinner;
 163     private Spinner mHiddenSettingsSpinner;
 164     private Spinner mPrivacySettingsSpinner;
 165     private TextView mHiddenWarningView;
 166     private TextView mProxyHostView;
 167     private TextView mProxyPortView;
 168     private TextView mProxyExclusionListView;
 169     private TextView mProxyPacView;
 170     private CheckBox mSharedCheckBox;
 171
 172     private IpAssignment mIpAssignment = IpAssignment.UNASSIGNED;
 173     private ProxySettings mProxySettings = ProxySettings.UNASSIGNED;
 174     private ProxyInfo mHttpProxy = null;
 175     private StaticIpConfiguration mStaticIpConfiguration = null;
 176
 177     private String[] mLevels;
 178     private int mMode;
 179     private TextView mSsidView;
 180
 181     private Context mContext;
 182
 183     @VisibleForTesting
 184     Integer mSecurityInPosition[];
 185
 186     private final WifiManager mWifiManager;
 187
 188     public WifiConfigController(WifiConfigUiBase parent, View view, AccessPoint accessPoint,
 189             int mode) {
 190         mConfigUi = parent;
 191
 192         mView = view;
 193         mAccessPoint = accessPoint;
 194         mContext = mConfigUi.getContext();
 195
 196         // Init Wi-Fi manager
 197         mWifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
 198         initWifiConfigController(accessPoint, mode);
 199     }
 200
 201     @VisibleForTesting
 202     public WifiConfigController(WifiConfigUiBase parent, View view, AccessPoint accessPoint,
 203             int mode, WifiManager wifiManager) {
 204         mConfigUi = parent;
 205
 206         mView = view;
 207         mAccessPoint = accessPoint;
 208         mContext = mConfigUi.getContext();
 209         mWifiManager = wifiManager;
 210         initWifiConfigController(accessPoint, mode);
 211     }
 212
 213     private void initWifiConfigController(AccessPoint accessPoint, int mode) {
 214
 215         mAccessPointSecurity = (accessPoint == null) ? AccessPoint.SECURITY_NONE :
 216                 accessPoint.getSecurity();
 217         mMode = mode;
 218
 219         final Resources res = mContext.getResources();
 220
 221         mLevels = res.getStringArray(R.array.wifi_signal);
 222         if (Utils.isWifiOnly(mContext) || !mContext.getResources().getBoolean(
 223                 com.android.internal.R.bool.config_eap_sim_based_auth_supported)) {
 224             mPhase2PeapAdapter = new ArrayAdapter<String>(
 225                     mContext, android.R.layout.simple_spinner_item,
 226                     res.getStringArray(R.array.wifi_peap_phase2_entries));
 227         } else {
 228             mPhase2PeapAdapter = new ArrayAdapter<String>(
 229                     mContext, android.R.layout.simple_spinner_item,
 230                     res.getStringArray(R.array.wifi_peap_phase2_entries_with_sim_auth));
 231         }
 232         mPhase2PeapAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
 233
 234         mPhase2FullAdapter = new ArrayAdapter<String>(
 235                 mContext, android.R.layout.simple_spinner_item,
 236                 res.getStringArray(R.array.wifi_phase2_entries));
 237         mPhase2FullAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
 238
 239         mUnspecifiedCertString = mContext.getString(R.string.wifi_unspecified);
 240         mMultipleCertSetString = mContext.getString(R.string.wifi_multiple_cert_added);
 241         mUseSystemCertsString = mContext.getString(R.string.wifi_use_system_certs);
 242         mDoNotProvideEapUserCertString =
 243             mContext.getString(R.string.wifi_do_not_provide_eap_user_cert);
 244         mDoNotValidateEapServerString =
 245             mContext.getString(R.string.wifi_do_not_validate_eap_server);
 246
 247         mSsidScanButton = (ImageButton) mView.findViewById(R.id.ssid_scanner_button);
 248         mPasswordScanButton = (ImageButton) mView.findViewById(R.id.password_scanner_button);
 249         mDialogContainer = mView.findViewById(R.id.dialog_scrollview);
 250         mIpSettingsSpinner = (Spinner) mView.findViewById(R.id.ip_settings);
 251         mIpSettingsSpinner.setOnItemSelectedListener(this);
 252         mProxySettingsSpinner = (Spinner) mView.findViewById(R.id.proxy_settings);
 253         mProxySettingsSpinner.setOnItemSelectedListener(this);
 254         mSharedCheckBox = (CheckBox) mView.findViewById(R.id.shared);
 255         mMeteredSettingsSpinner = mView.findViewById(R.id.metered_settings);
 256         mHiddenSettingsSpinner = mView.findViewById(R.id.hidden_settings);
 257         mPrivacySettingsSpinner = mView.findViewById(R.id.privacy_settings);
 258         if (mContext.getResources().getBoolean(
 259                 com.android.internal.R.bool.config_wifi_connected_mac_randomization_supported)) {
 260             View privacySettingsLayout = mView.findViewById(R.id.privacy_settings_fields);
 261             privacySettingsLayout.setVisibility(View.VISIBLE);
 262         }
 263         mHiddenSettingsSpinner.setOnItemSelectedListener(this);
 264         mHiddenWarningView = mView.findViewById(R.id.hidden_settings_warning);
 265         mHiddenWarningView.setVisibility(
 266                 mHiddenSettingsSpinner.getSelectedItemPosition() == NOT_HIDDEN_NETWORK
 267                         ? View.GONE
 268                         : View.VISIBLE);
 269         mSecurityInPosition = new Integer[AccessPoint.SECURITY_MAX_VAL];
 270
 271         if (mAccessPoint == null) { // new network
 272             configureSecuritySpinner();
 273             mConfigUi.setSubmitButton(res.getString(R.string.wifi_save));
 274             mPasswordScanButton.setVisibility(View.GONE);
 275         } else {
 276             mConfigUi.setTitle(mAccessPoint.getTitle());
 277
 278             ViewGroup group = (ViewGroup) mView.findViewById(R.id.info);
 279
 280             boolean showAdvancedFields = false;
 281             if (mAccessPoint.isSaved()) {
 282                 WifiConfiguration config = mAccessPoint.getConfig();
 283                 mMeteredSettingsSpinner.setSelection(config.meteredOverride);
 284                 mHiddenSettingsSpinner.setSelection(config.hiddenSSID
 285                         ? HIDDEN_NETWORK
 286                         : NOT_HIDDEN_NETWORK);
 287
 288                 final int prefMacValue =
 289                         WifiPrivacyPreferenceController.translateMacRandomizedValueToPrefValue(
 290                                 config.macRandomizationSetting);
 291                 mPrivacySettingsSpinner.setSelection(prefMacValue);
 292
 293                 if (config.getIpAssignment() == IpAssignment.STATIC) {
 294                     mIpSettingsSpinner.setSelection(STATIC_IP);
 295                     showAdvancedFields = true;
 296                     // Display IP address.
 297                     StaticIpConfiguration staticConfig = config.getStaticIpConfiguration();
 298                     if (staticConfig != null && staticConfig.ipAddress != null) {
 299                         addRow(group, R.string.wifi_ip_address,
 300                                 staticConfig.ipAddress.getAddress().getHostAddress());
 301                     }
 302                 } else {
 303                     mIpSettingsSpinner.setSelection(DHCP);
 304                 }
 305
 306                 mSharedCheckBox.setEnabled(config.shared);
 307                 if (!config.shared) {
 308                     showAdvancedFields = true;
 309                 }
 310
 311                 if (config.getProxySettings() == ProxySettings.STATIC) {
 312                     mProxySettingsSpinner.setSelection(PROXY_STATIC);
 313                     showAdvancedFields = true;
 314                 } else if (config.getProxySettings() == ProxySettings.PAC) {
 315                     mProxySettingsSpinner.setSelection(PROXY_PAC);
 316                     showAdvancedFields = true;
 317                 } else {
 318                     mProxySettingsSpinner.setSelection(PROXY_NONE);
 319                 }
 320                 if (config != null && config.isPasspoint()) {
 321                     addRow(group, R.string.passpoint_label,
 322                             String.format(mContext.getString(R.string.passpoint_content),
 323                             config.providerFriendlyName));
 324                 }
 325             }
 326
 327             if ((!mAccessPoint.isSaved() && !mAccessPoint.isActive()
 328                     && !mAccessPoint.isPasspointConfig())
 329                     || mMode != WifiConfigUiBase.MODE_VIEW) {
 330                 showSecurityFields(true /* refreshEapMethods */, true /* refreshCertificates */);
 331                 showIpConfigFields();
 332                 showProxyFields();
 333                 final CheckBox advancedTogglebox =
 334                         (CheckBox) mView.findViewById(R.id.wifi_advanced_togglebox);
 335                 mView.findViewById(R.id.wifi_advanced_toggle).setVisibility(
 336                         mAccessPoint.isCarrierAp() ? View.GONE : View.VISIBLE);
 337                 advancedTogglebox.setOnCheckedChangeListener(this);
 338                 advancedTogglebox.setChecked(showAdvancedFields);
 339                 mView.findViewById(R.id.wifi_advanced_fields)
 340                         .setVisibility(showAdvancedFields ? View.VISIBLE : View.GONE);
 341                 if (mAccessPoint.isCarrierAp()) {
 342                     addRow(group, R.string.wifi_carrier_connect,
 343                             String.format(mContext.getString(R.string.wifi_carrier_content),
 344                             mAccessPoint.getCarrierName()));
 345                 }
 346             }
 347
 348             if (mMode == WifiConfigUiBase.MODE_MODIFY) {
 349                 mConfigUi.setSubmitButton(res.getString(R.string.wifi_save));
 350             } else if (mMode == WifiConfigUiBase.MODE_CONNECT) {
 351                 mConfigUi.setSubmitButton(res.getString(R.string.wifi_connect));
 352             } else {
 353                 final DetailedState state = mAccessPoint.getDetailedState();
 354                 final String signalLevel = getSignalString();
 355
 356                 if ((state == null || state == DetailedState.DISCONNECTED) && signalLevel != null) {
 357                     mConfigUi.setSubmitButton(res.getString(R.string.wifi_connect));
 358                 } else {
 359                     if (state != null) {
 360                         boolean isEphemeral = mAccessPoint.isEphemeral();
 361                         WifiConfiguration config = mAccessPoint.getConfig();
 362                         String providerFriendlyName = null;
 363                         if (config != null && config.isPasspoint()) {
 364                             providerFriendlyName = config.providerFriendlyName;
 365                         }
 366                         String suggestionOrSpecifierPackageName = null;
 367                         if (config != null
 368                                 && (config.fromWifiNetworkSpecifier
 369                                 || config.fromWifiNetworkSuggestion)) {
 370                             suggestionOrSpecifierPackageName = config.creatorName;
 371                         }
 372                         String summary = AccessPoint.getSummary(
 373                                 mConfigUi.getContext(), /* ssid */ null, state, isEphemeral,
 374                                 suggestionOrSpecifierPackageName);
 375                         addRow(group, R.string.wifi_status, summary);
 376                     }
 377
 378                     if (signalLevel != null) {
 379                         addRow(group, R.string.wifi_signal, signalLevel);
 380                     }
 381
 382                     WifiInfo info = mAccessPoint.getInfo();
 383                     if (info != null && info.getTxLinkSpeedMbps() != WifiInfo.LINK_SPEED_UNKNOWN) {
 384                         addRow(group, R.string.tx_wifi_speed, String.format(
 385                                 res.getString(R.string.tx_link_speed), info.getTxLinkSpeedMbps()));
 386                     }
 387
 388                     if (info != null && info.getRxLinkSpeedMbps() != WifiInfo.LINK_SPEED_UNKNOWN) {
 389                         addRow(group, R.string.rx_wifi_speed, String.format(
 390                                 res.getString(R.string.rx_link_speed), info.getRxLinkSpeedMbps()));
 391                     }
 392
 393                     if (info != null && info.getFrequency() != -1) {
 394                         final int frequency = info.getFrequency();
 395                         String band = null;
 396
 397                         if (frequency >= AccessPoint.LOWER_FREQ_24GHZ
 398                                 && frequency < AccessPoint.HIGHER_FREQ_24GHZ) {
 399                             band = res.getString(R.string.wifi_band_24ghz);
 400                         } else if (frequency >= AccessPoint.LOWER_FREQ_5GHZ
 401                                 && frequency < AccessPoint.HIGHER_FREQ_5GHZ) {
 402                             band = res.getString(R.string.wifi_band_5ghz);
 403                         } else {
 404                             Log.e(TAG, "Unexpected frequency " + frequency);
 405                         }
 406                         if (band != null) {
 407                             addRow(group, R.string.wifi_frequency, band);
 408                         }
 409                     }
 410
 411                     addRow(group, R.string.wifi_security, mAccessPoint.getSecurityString(false));
 412                     mView.findViewById(R.id.ip_fields).setVisibility(View.GONE);
 413                 }
 414                 if (mAccessPoint.isSaved() || mAccessPoint.isActive()
 415                         || mAccessPoint.isPasspointConfig()) {
 416                     mConfigUi.setForgetButton(res.getString(R.string.wifi_forget));
 417                 }
 418             }
 419
 420             if (!WifiDppUtils.isSupportEnrolleeQrCodeScanner(mContext, mAccessPointSecurity)) {
 421                 mPasswordScanButton.setVisibility(View.GONE);
 422             }
 423             mSsidScanButton.setVisibility(View.GONE);
 424         }
 425
 426         if (!isSplitSystemUser()) {
 427             mSharedCheckBox.setVisibility(View.GONE);
 428         }
 429
 430         mConfigUi.setCancelButton(res.getString(R.string.wifi_cancel));
 431         if (mConfigUi.getSubmitButton() != null) {
 432             enableSubmitIfAppropriate();
 433         }
 434
 435         // After done view show and hide, request focus from parent view
 436         mView.findViewById(R.id.l_wifidialog).requestFocus();
 437     }
 438
 439     @VisibleForTesting
 440     boolean isSplitSystemUser() {
 441         final UserManager userManager =
 442                 (UserManager) mContext.getSystemService(Context.USER_SERVICE);
 443         return userManager.isSplitSystemUser();
 444     }
 445
 446     private void addRow(ViewGroup group, int name, String value) {
 447         View row = mConfigUi.getLayoutInflater().inflate(R.layout.wifi_dialog_row, group, false);
 448         ((TextView) row.findViewById(R.id.name)).setText(name);
 449         ((TextView) row.findViewById(R.id.value)).setText(value);
 450         group.addView(row);
 451     }
 452
 453     @VisibleForTesting
 454     String getSignalString() {
 455         if (!mAccessPoint.isReachable()) {
 456             return null;
 457         }
 458         final int level = mAccessPoint.getLevel();
 459
 460         return (level > -1 && level < mLevels.length) ? mLevels[level] : null;
 461     }
 462
 463     void hideForgetButton() {
 464         Button forget = mConfigUi.getForgetButton();
 465         if (forget == null) return;
 466
 467         forget.setVisibility(View.GONE);
 468     }
 469
 470     void hideSubmitButton() {
 471         Button submit = mConfigUi.getSubmitButton();
 472         if (submit == null) return;
 473
 474         submit.setVisibility(View.GONE);
 475     }
 476
 477     /* show submit button if password, ip and proxy settings are valid */
 478     void enableSubmitIfAppropriate() {
 479         Button submit = mConfigUi.getSubmitButton();
 480         if (submit == null) return;
 481
 482         submit.setEnabled(isSubmittable());
 483     }
 484
 485     boolean isValidPsk(String password) {
 486         if (password.length() == 64 && password.matches("[0-9A-Fa-f]{64}")) {
 487             return true;
 488         } else if (password.length() >= 8 && password.length() <= 63) {
 489             return true;
 490         }
 491         return false;
 492     }
 493
 494     boolean isValidSaePassword(String password) {
 495         if (password.length() >= 1 && password.length() <= 63) {
 496             return true;
 497         }
 498         return false;
 499     }
 500
 501     boolean isSubmittable() {
 502         boolean enabled = false;
 503         boolean passwordInvalid = false;
 504         if (mPasswordView != null
 505                 && ((mAccessPointSecurity == AccessPoint.SECURITY_WEP
 506                         && mPasswordView.length() == 0)
 507                     || (mAccessPointSecurity == AccessPoint.SECURITY_PSK
 508                            && !isValidPsk(mPasswordView.getText().toString()))
 509                     || (mAccessPointSecurity == AccessPoint.SECURITY_SAE
 510                         && !isValidSaePassword(mPasswordView.getText().toString())))) {
 511             passwordInvalid = true;
 512         }
 513         if ((mSsidView != null && mSsidView.length() == 0)
 514                 // If Accesspoint is not saved, apply passwordInvalid check
 515                 || ((mAccessPoint == null || !mAccessPoint.isSaved()) && passwordInvalid
 516                 // If AccessPoint is saved (modifying network) and password is changed, apply
 517                 // Invalid password check
 518                 || mAccessPoint != null && mAccessPoint.isSaved() && passwordInvalid
 519                     && mPasswordView.length() > 0)) {
 520             enabled = false;
 521         } else {
 522             enabled = ipAndProxyFieldsAreValid();
 523         }
 524         if ((mAccessPointSecurity == AccessPoint.SECURITY_EAP ||
 525                 mAccessPointSecurity == AccessPoint.SECURITY_EAP_SUITE_B)
 526                 && mEapCaCertSpinner != null
 527                 && mView.findViewById(R.id.l_ca_cert).getVisibility() != View.GONE) {
 528             String caCertSelection = (String) mEapCaCertSpinner.getSelectedItem();
 529             if (caCertSelection.equals(mUnspecifiedCertString)) {
 530                 // Disallow submit if the user has not selected a CA certificate for an EAP network
 531                 // configuration.
 532                 enabled = false;
 533             }
 534             if (caCertSelection.equals(mUseSystemCertsString)
 535                     && mEapDomainView != null
 536                     && mView.findViewById(R.id.l_domain).getVisibility() != View.GONE
 537                     && TextUtils.isEmpty(mEapDomainView.getText().toString())) {
 538                 // Disallow submit if the user chooses to use system certificates for EAP server
 539                 // validation, but does not provide a domain.
 540                 enabled = false;
 541             }
 542         }
 543         if ((mAccessPointSecurity == AccessPoint.SECURITY_EAP ||
 544                 mAccessPointSecurity == AccessPoint.SECURITY_EAP_SUITE_B)
 545                 && mEapUserCertSpinner != null
 546                 && mView.findViewById(R.id.l_user_cert).getVisibility() != View.GONE
 547                 && mEapUserCertSpinner.getSelectedItem().equals(mUnspecifiedCertString)) {
 548             // Disallow submit if the user has not selected a user certificate for an EAP network
 549             // configuration.
 550             enabled = false;
 551         }
 552         return enabled;
 553     }
 554
 555     void showWarningMessagesIfAppropriate() {
 556         mView.findViewById(R.id.no_ca_cert_warning).setVisibility(View.GONE);
 557         mView.findViewById(R.id.no_domain_warning).setVisibility(View.GONE);
 558         mView.findViewById(R.id.ssid_too_long_warning).setVisibility(View.GONE);
 559
 560         if (mSsidView != null) {
 561             final String ssid = mSsidView.getText().toString();
 562             if (WifiUtils.isSSIDTooLong(ssid)) {
 563                 mView.findViewById(R.id.ssid_too_long_warning).setVisibility(View.VISIBLE);
 564             }
 565         }
 566         if (mEapCaCertSpinner != null
 567                 && mView.findViewById(R.id.l_ca_cert).getVisibility() != View.GONE) {
 568             String caCertSelection = (String) mEapCaCertSpinner.getSelectedItem();
 569             if (caCertSelection.equals(mDoNotValidateEapServerString)) {
 570                 // Display warning if user chooses not to validate the EAP server with a
 571                 // user-supplied CA certificate in an EAP network configuration.
 572                 mView.findViewById(R.id.no_ca_cert_warning).setVisibility(View.VISIBLE);
 573             }
 574             if (caCertSelection.equals(mUseSystemCertsString)
 575                     && mEapDomainView != null
 576                     && mView.findViewById(R.id.l_domain).getVisibility() != View.GONE
 577                     && TextUtils.isEmpty(mEapDomainView.getText().toString())) {
 578                 // Display warning if user chooses to use pre-installed public CA certificates
 579                 // without restricting the server domain that these certificates can be used to
 580                 // validate.
 581                 mView.findViewById(R.id.no_domain_warning).setVisibility(View.VISIBLE);
 582             }
 583         }
 584     }
 585
 586     public WifiConfiguration getConfig() {
 587         if (mMode == WifiConfigUiBase.MODE_VIEW) {
 588             return null;
 589         }
 590
 591         WifiConfiguration config = new WifiConfiguration();
 592
 593         if (mAccessPoint == null) {
 594             config.SSID = AccessPoint.convertToQuotedString(
 595                     mSsidView.getText().toString());
 596             // If the user adds a network manually, assume that it is hidden.
 597             config.hiddenSSID = mHiddenSettingsSpinner.getSelectedItemPosition() == HIDDEN_NETWORK;
 598         } else if (!mAccessPoint.isSaved()) {
 599             config.SSID = AccessPoint.convertToQuotedString(
 600                     mAccessPoint.getSsidStr());
 601         } else {
 602             config.networkId = mAccessPoint.getConfig().networkId;
 603             config.hiddenSSID = mAccessPoint.getConfig().hiddenSSID;
 604         }
 605
 606         config.shared = mSharedCheckBox.isChecked();
 607
 608         switch (mAccessPointSecurity) {
 609             case AccessPoint.SECURITY_NONE:
 610                 config.allowedKeyManagement.set(KeyMgmt.NONE);
 611                 break;
 612
 613             case AccessPoint.SECURITY_WEP:
 614                 config.allowedKeyManagement.set(KeyMgmt.NONE);
 615                 config.allowedAuthAlgorithms.set(AuthAlgorithm.OPEN);
 616                 config.allowedAuthAlgorithms.set(AuthAlgorithm.SHARED);
 617                 if (mPasswordView.length() != 0) {
 618                     int length = mPasswordView.length();
 619                     String password = mPasswordView.getText().toString();
 620                     // WEP-40, WEP-104, and 256-bit WEP (WEP-232?)
 621                     if ((length == 10 || length == 26 || length == 58)
 622                             && password.matches("[0-9A-Fa-f]*")) {
 623                         config.wepKeys[0] = password;
 624                     } else {
 625                         config.wepKeys[0] = '"' + password + '"';
 626                     }
 627                 }
 628                 break;
 629
 630             case AccessPoint.SECURITY_PSK:
 631                 config.allowedKeyManagement.set(KeyMgmt.WPA_PSK);
 632                 if (mPasswordView.length() != 0) {
 633                     String password = mPasswordView.getText().toString();
 634                     if (password.matches("[0-9A-Fa-f]{64}")) {
 635                         config.preSharedKey = password;
 636                     } else {
 637                         config.preSharedKey = '"' + password + '"';
 638                     }
 639                 }
 640                 break;
 641
 642             case AccessPoint.SECURITY_EAP:
 643             case AccessPoint.SECURITY_EAP_SUITE_B:
 644                 config.allowedKeyManagement.set(KeyMgmt.WPA_EAP);
 645                 config.allowedKeyManagement.set(KeyMgmt.IEEE8021X);
 646                 if (mAccessPointSecurity == AccessPoint.SECURITY_EAP_SUITE_B) {
 647                     config.allowedKeyManagement.set(KeyMgmt.SUITE_B_192);
 648                     config.requirePMF = true;
 649                     config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.GCMP_256);
 650                     config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.GCMP_256);
 651                     config.allowedGroupManagementCiphers.set(WifiConfiguration.GroupMgmtCipher
 652                             .BIP_GMAC_256);
 653                     // allowedSuiteBCiphers will be set according to certificate type
 654                 }
 655                 config.enterpriseConfig = new WifiEnterpriseConfig();
 656                 int eapMethod = mEapMethodSpinner.getSelectedItemPosition();
 657                 int phase2Method = mPhase2Spinner.getSelectedItemPosition();
 658                 config.enterpriseConfig.setEapMethod(eapMethod);
 659                 switch (eapMethod) {
 660                     case Eap.PEAP:
 661                         // PEAP supports limited phase2 values
 662                         // Map the index from the mPhase2PeapAdapter to the one used
 663                         // by the API which has the full list of PEAP methods.
 664                         switch(phase2Method) {
 665                             case WIFI_PEAP_PHASE2_NONE:
 666                                 config.enterpriseConfig.setPhase2Method(Phase2.NONE);
 667                                 break;
 668                             case WIFI_PEAP_PHASE2_MSCHAPV2:
 669                                 config.enterpriseConfig.setPhase2Method(Phase2.MSCHAPV2);
 670                                 break;
 671                             case WIFI_PEAP_PHASE2_GTC:
 672                                 config.enterpriseConfig.setPhase2Method(Phase2.GTC);
 673                                 break;
 674                             case WIFI_PEAP_PHASE2_SIM:
 675                                 config.enterpriseConfig.setPhase2Method(Phase2.SIM);
 676                                 break;
 677                             case WIFI_PEAP_PHASE2_AKA:
 678                                 config.enterpriseConfig.setPhase2Method(Phase2.AKA);
 679                                 break;
 680                             case WIFI_PEAP_PHASE2_AKA_PRIME:
 681                                 config.enterpriseConfig.setPhase2Method(Phase2.AKA_PRIME);
 682                                 break;
 683                             default:
 684                                 Log.e(TAG, "Unknown phase2 method" + phase2Method);
 685                                 break;
 686                         }
 687                         break;
 688                     default:
 689                         // The default index from mPhase2FullAdapter maps to the API
 690                         config.enterpriseConfig.setPhase2Method(phase2Method);
 691                         break;
 692                 }
 693
 694                 String caCert = (String) mEapCaCertSpinner.getSelectedItem();
 695                 config.enterpriseConfig.setCaCertificateAliases(null);
 696                 config.enterpriseConfig.setCaPath(null);
 697                 config.enterpriseConfig.setDomainSuffixMatch(mEapDomainView.getText().toString());
 698                 if (caCert.equals(mUnspecifiedCertString)
 699                         || caCert.equals(mDoNotValidateEapServerString)) {
 700                     // ca_cert already set to null, so do nothing.
 701                 } else if (caCert.equals(mUseSystemCertsString)) {
 702                     config.enterpriseConfig.setCaPath(SYSTEM_CA_STORE_PATH);
 703                 } else if (caCert.equals(mMultipleCertSetString)) {
 704                     if (mAccessPoint != null) {
 705                         if (!mAccessPoint.isSaved()) {
 706                             Log.e(TAG, "Multiple certs can only be set "
 707                                     + "when editing saved network");
 708                         }
 709                         config.enterpriseConfig.setCaCertificateAliases(
 710                                 mAccessPoint
 711                                         .getConfig()
 712                                         .enterpriseConfig
 713                                         .getCaCertificateAliases());
 714                     }
 715                 } else {
 716                     config.enterpriseConfig.setCaCertificateAliases(new String[] {caCert});
 717                 }
 718
 719                 // ca_cert or ca_path should not both be non-null, since we only intend to let
 720                 // the use either their own certificate, or the system certificates, not both.
 721                 // The variable that is not used must explicitly be set to null, so that a
 722                 // previously-set value on a saved configuration will be erased on an update.
 723                 if (config.enterpriseConfig.getCaCertificateAliases() != null
 724                         && config.enterpriseConfig.getCaPath() != null) {
 725                     Log.e(TAG, "ca_cert ("
 726                             + config.enterpriseConfig.getCaCertificateAliases()
 727                             + ") and ca_path ("
 728                             + config.enterpriseConfig.getCaPath()
 729                             + ") should not both be non-null");
 730                 }
 731
 732                 String clientCert = (String) mEapUserCertSpinner.getSelectedItem();
 733                 if (clientCert.equals(mUnspecifiedCertString)
 734                         || clientCert.equals(mDoNotProvideEapUserCertString)) {
 735                     // Note: |clientCert| should not be able to take the value |unspecifiedCert|,
 736                     // since we prevent such configurations from being saved.
 737                     clientCert = "";
 738                 }
 739                 config.enterpriseConfig.setClientCertificateAlias(clientCert);
 740                 if (eapMethod == Eap.SIM || eapMethod == Eap.AKA || eapMethod == Eap.AKA_PRIME) {
 741                     config.enterpriseConfig.setIdentity("");
 742                     config.enterpriseConfig.setAnonymousIdentity("");
 743                 } else if (eapMethod == Eap.PWD) {
 744                     config.enterpriseConfig.setIdentity(mEapIdentityView.getText().toString());
 745                     config.enterpriseConfig.setAnonymousIdentity("");
 746                 } else {
 747                     config.enterpriseConfig.setIdentity(mEapIdentityView.getText().toString());
 748                     config.enterpriseConfig.setAnonymousIdentity(
 749                             mEapAnonymousView.getText().toString());
 750                 }
 751
 752                 if (mPasswordView.isShown()) {
 753                     // For security reasons, a previous password is not displayed to user.
 754                     // Update only if it has been changed.
 755                     if (mPasswordView.length() > 0) {
 756                         config.enterpriseConfig.setPassword(mPasswordView.getText().toString());
 757                     }
 758                 } else {
 759                     // clear password
 760                     config.enterpriseConfig.setPassword(mPasswordView.getText().toString());
 761                 }
 762                 break;
 763             case AccessPoint.SECURITY_SAE:
 764                 config.allowedKeyManagement.set(KeyMgmt.SAE);
 765                 config.requirePMF = true;
 766                 if (mPasswordView.length() != 0) {
 767                     String password = mPasswordView.getText().toString();
 768                     config.preSharedKey = '"' + password + '"';
 769                 }
 770                 break;
 771
 772             case AccessPoint.SECURITY_OWE:
 773                 config.allowedKeyManagement.set(KeyMgmt.OWE);
 774                 config.requirePMF = true;
 775                 break;
 776
 777             default:
 778                 return null;
 779         }
 780
 781         config.setIpConfiguration(
 782                 new IpConfiguration(mIpAssignment, mProxySettings,
 783                                     mStaticIpConfiguration, mHttpProxy));
 784         if (mMeteredSettingsSpinner != null) {
 785             config.meteredOverride = mMeteredSettingsSpinner.getSelectedItemPosition();
 786         }
 787
 788         if (mPrivacySettingsSpinner != null) {
 789             final int macValue =
 790                     WifiPrivacyPreferenceController.translatePrefValueToMacRandomizedValue(
 791                             mPrivacySettingsSpinner.getSelectedItemPosition());
 792             config.macRandomizationSetting = macValue;
 793         }
 794
 795         return config;
 796     }
 797
 798     private boolean ipAndProxyFieldsAreValid() {
 799         mIpAssignment =
 800                 (mIpSettingsSpinner != null
 801                     && mIpSettingsSpinner.getSelectedItemPosition() == STATIC_IP)
 802                 ? IpAssignment.STATIC
 803                 : IpAssignment.DHCP;
 804
 805         if (mIpAssignment == IpAssignment.STATIC) {
 806             mStaticIpConfiguration = new StaticIpConfiguration();
 807             int result = validateIpConfigFields(mStaticIpConfiguration);
 808             if (result != 0) {
 809                 return false;
 810             }
 811         }
 812
 813         final int selectedPosition = mProxySettingsSpinner.getSelectedItemPosition();
 814         mProxySettings = ProxySettings.NONE;
 815         mHttpProxy = null;
 816         if (selectedPosition == PROXY_STATIC && mProxyHostView != null) {
 817             mProxySettings = ProxySettings.STATIC;
 818             String host = mProxyHostView.getText().toString();
 819             String portStr = mProxyPortView.getText().toString();
 820             String exclusionList = mProxyExclusionListView.getText().toString();
 821             int port = 0;
 822             int result = 0;
 823             try {
 824                 port = Integer.parseInt(portStr);
 825                 result = ProxySelector.validate(host, portStr, exclusionList);
 826             } catch (NumberFormatException e) {
 827                 result = R.string.proxy_error_invalid_port;
 828             }
 829             if (result == 0) {
 830                 mHttpProxy = new ProxyInfo(host, port, exclusionList);
 831             } else {
 832                 return false;
 833             }
 834         } else if (selectedPosition == PROXY_PAC && mProxyPacView != null) {
 835             mProxySettings = ProxySettings.PAC;
 836             CharSequence uriSequence = mProxyPacView.getText();
 837             if (TextUtils.isEmpty(uriSequence)) {
 838                 return false;
 839             }
 840             Uri uri = Uri.parse(uriSequence.toString());
 841             if (uri == null) {
 842                 return false;
 843             }
 844             mHttpProxy = new ProxyInfo(uri);
 845         }
 846         return true;
 847     }
 848
 849     private Inet4Address getIPv4Address(String text) {
 850         try {
 851             return (Inet4Address) NetworkUtils.numericToInetAddress(text);
 852         } catch (IllegalArgumentException | ClassCastException e) {
 853             return null;
 854         }
 855     }
 856
 857     private int validateIpConfigFields(StaticIpConfiguration staticIpConfiguration) {
 858         if (mIpAddressView == null) return 0;
 859
 860         String ipAddr = mIpAddressView.getText().toString();
 861         if (TextUtils.isEmpty(ipAddr)) return R.string.wifi_ip_settings_invalid_ip_address;
 862
 863         Inet4Address inetAddr = getIPv4Address(ipAddr);
 864         if (inetAddr == null || inetAddr.equals(Inet4Address.ANY)) {
 865             return R.string.wifi_ip_settings_invalid_ip_address;
 866         }
 867
 868         int networkPrefixLength = -1;
 869         try {
 870             networkPrefixLength = Integer.parseInt(mNetworkPrefixLengthView.getText().toString());
 871             if (networkPrefixLength < 0 || networkPrefixLength > 32) {
 872                 return R.string.wifi_ip_settings_invalid_network_prefix_length;
 873             }
 874             staticIpConfiguration.ipAddress = new LinkAddress(inetAddr, networkPrefixLength);
 875         } catch (NumberFormatException e) {
 876             // Set the hint as default after user types in ip address
 877             mNetworkPrefixLengthView.setText(mConfigUi.getContext().getString(
 878                     R.string.wifi_network_prefix_length_hint));
 879         } catch (IllegalArgumentException e) {
 880             return R.string.wifi_ip_settings_invalid_ip_address;
 881         }
 882
 883         String gateway = mGatewayView.getText().toString();
 884         if (TextUtils.isEmpty(gateway)) {
 885             try {
 886                 //Extract a default gateway from IP address
 887                 InetAddress netPart = NetworkUtils.getNetworkPart(inetAddr, networkPrefixLength);
 888                 byte[] addr = netPart.getAddress();
 889                 addr[addr.length - 1] = 1;
 890                 mGatewayView.setText(InetAddress.getByAddress(addr).getHostAddress());
 891             } catch (RuntimeException ee) {
 892             } catch (java.net.UnknownHostException u) {
 893             }
 894         } else {
 895             InetAddress gatewayAddr = getIPv4Address(gateway);
 896             if (gatewayAddr == null) {
 897                 return R.string.wifi_ip_settings_invalid_gateway;
 898             }
 899             if (gatewayAddr.isMulticastAddress()) {
 900                 return R.string.wifi_ip_settings_invalid_gateway;
 901             }
 902             staticIpConfiguration.gateway = gatewayAddr;
 903         }
 904
 905         String dns = mDns1View.getText().toString();
 906         InetAddress dnsAddr = null;
 907
 908         if (TextUtils.isEmpty(dns)) {
 909             //If everything else is valid, provide hint as a default option
 910             mDns1View.setText(mConfigUi.getContext().getString(R.string.wifi_dns1_hint));
 911         } else {
 912             dnsAddr = getIPv4Address(dns);
 913             if (dnsAddr == null) {
 914                 return R.string.wifi_ip_settings_invalid_dns;
 915             }
 916             staticIpConfiguration.dnsServers.add(dnsAddr);
 917         }
 918
 919         if (mDns2View.length() > 0) {
 920             dns = mDns2View.getText().toString();
 921             dnsAddr = getIPv4Address(dns);
 922             if (dnsAddr == null) {
 923                 return R.string.wifi_ip_settings_invalid_dns;
 924             }
 925             staticIpConfiguration.dnsServers.add(dnsAddr);
 926         }
 927         return 0;
 928     }
 929
 930     private void showSecurityFields(boolean refreshEapMethods, boolean refreshCertificates) {
 931         if (mAccessPointSecurity == AccessPoint.SECURITY_NONE ||
 932                 mAccessPointSecurity == AccessPoint.SECURITY_OWE) {
 933             mView.findViewById(R.id.security_fields).setVisibility(View.GONE);
 934             return;
 935         }
 936         mView.findViewById(R.id.security_fields).setVisibility(View.VISIBLE);
 937
 938         if (mPasswordView == null) {
 939             mPasswordView = (TextView) mView.findViewById(R.id.password);
 940             mPasswordView.addTextChangedListener(this);
 941             mPasswordView.setOnEditorActionListener(this);
 942             mPasswordView.setOnKeyListener(this);
 943             ((CheckBox) mView.findViewById(R.id.show_password))
 944                 .setOnCheckedChangeListener(this);
 945
 946             if (mAccessPoint != null && mAccessPoint.isSaved()) {
 947                 mPasswordView.setHint(R.string.wifi_unchanged);
 948             }
 949         }
 950
 951         if (mAccessPointSecurity != AccessPoint.SECURITY_EAP &&
 952                 mAccessPointSecurity != AccessPoint.SECURITY_EAP_SUITE_B) {
 953             mView.findViewById(R.id.eap).setVisibility(View.GONE);
 954             return;
 955         }
 956         mView.findViewById(R.id.eap).setVisibility(View.VISIBLE);
 957
 958         boolean initiateEnterpriseNetworkUi = false;
 959         if (mEapMethodSpinner == null) {
 960             initiateEnterpriseNetworkUi = true;
 961             mEapMethodSpinner = (Spinner) mView.findViewById(R.id.method);
 962             mEapMethodSpinner.setOnItemSelectedListener(this);
 963             mPhase2Spinner = (Spinner) mView.findViewById(R.id.phase2);
 964             mPhase2Spinner.setOnItemSelectedListener(this);
 965             mEapCaCertSpinner = (Spinner) mView.findViewById(R.id.ca_cert);
 966             mEapCaCertSpinner.setOnItemSelectedListener(this);
 967             mEapDomainView = (TextView) mView.findViewById(R.id.domain);
 968             mEapDomainView.addTextChangedListener(this);
 969             mEapUserCertSpinner = (Spinner) mView.findViewById(R.id.user_cert);
 970             mEapUserCertSpinner.setOnItemSelectedListener(this);
 971             mEapIdentityView = (TextView) mView.findViewById(R.id.identity);
 972             mEapAnonymousView = (TextView) mView.findViewById(R.id.anonymous);
 973         }
 974
 975         if (refreshEapMethods) {
 976             ArrayAdapter<CharSequence> eapMethodSpinnerAdapter;
 977             if (mAccessPointSecurity == AccessPoint.SECURITY_EAP_SUITE_B) {
 978                 eapMethodSpinnerAdapter = getSpinnerAdapter(R.array.wifi_eap_method);
 979                 mEapMethodSpinner.setAdapter(eapMethodSpinnerAdapter);
 980                 // WAP3-Enterprise 192-bit only allows EAP method TLS
 981                 mEapMethodSpinner.setSelection(Eap.TLS);
 982                 mEapMethodSpinner.setEnabled(false);
 983             } else if (Utils.isWifiOnly(mContext) || !mContext.getResources().getBoolean(
 984                     com.android.internal.R.bool.config_eap_sim_based_auth_supported)) {
 985                 eapMethodSpinnerAdapter = getSpinnerAdapter(
 986                         R.array.eap_method_without_sim_auth);
 987                 mEapMethodSpinner.setAdapter(eapMethodSpinnerAdapter);
 988                 mEapMethodSpinner.setEnabled(true);
 989             } else {
 990                 eapMethodSpinnerAdapter = getSpinnerAdapter(R.array.wifi_eap_method);
 991                 mEapMethodSpinner.setAdapter(eapMethodSpinnerAdapter);
 992                 mEapMethodSpinner.setEnabled(true);
 993             }
 994         }
 995
 996         if (mAccessPointSecurity != AccessPoint.SECURITY_EAP_SUITE_B
 997                 && mAccessPoint != null
 998                 && mAccessPoint.isCarrierAp()) {
 999             mEapMethodSpinner.setSelection(mAccessPoint.getCarrierApEapType());
1000         }
1001
1002         if (refreshCertificates) {
1003             loadCertificates(
1004                     mEapCaCertSpinner,
1005                     Credentials.CA_CERTIFICATE,
1006                     mDoNotValidateEapServerString,
1007                     false,
1008                     true);
1009             loadCertificates(
1010                     mEapUserCertSpinner,
1011                     Credentials.USER_PRIVATE_KEY,
1012                     mDoNotProvideEapUserCertString,
1013                     false,
1014                     false);
1015         }
1016
1017         // Modifying an existing network
1018         if (initiateEnterpriseNetworkUi && mAccessPoint != null && mAccessPoint.isSaved()) {
1019             final WifiEnterpriseConfig enterpriseConfig = mAccessPoint.getConfig().enterpriseConfig;
1020             final int eapMethod = enterpriseConfig.getEapMethod();
1021             final int phase2Method = enterpriseConfig.getPhase2Method();
1022             mEapMethodSpinner.setSelection(eapMethod);
1023             showEapFieldsByMethod(eapMethod);
1024             switch (eapMethod) {
1025                 case Eap.PEAP:
1026                     switch (phase2Method) {
1027                         case Phase2.NONE:
1028                             mPhase2Spinner.setSelection(WIFI_PEAP_PHASE2_NONE);
1029                             break;
1030                         case Phase2.MSCHAPV2:
1031                             mPhase2Spinner.setSelection(WIFI_PEAP_PHASE2_MSCHAPV2);
1032                             break;
1033                         case Phase2.GTC:
1034                             mPhase2Spinner.setSelection(WIFI_PEAP_PHASE2_GTC);
1035                             break;
1036                         case Phase2.SIM:
1037                             mPhase2Spinner.setSelection(WIFI_PEAP_PHASE2_SIM);
1038                             break;
1039                         case Phase2.AKA:
1040                             mPhase2Spinner.setSelection(WIFI_PEAP_PHASE2_AKA);
1041                             break;
1042                         case Phase2.AKA_PRIME:
1043                             mPhase2Spinner.setSelection(WIFI_PEAP_PHASE2_AKA_PRIME);
1044                             break;
1045                         default:
1046                             Log.e(TAG, "Invalid phase 2 method " + phase2Method);
1047                             break;
1048                     }
1049                     break;
1050                 default:
1051                     mPhase2Spinner.setSelection(phase2Method);
1052                     break;
1053             }
1054             if (!TextUtils.isEmpty(enterpriseConfig.getCaPath())) {
1055                 setSelection(mEapCaCertSpinner, mUseSystemCertsString);
1056             } else {
1057                 final String[] caCerts = enterpriseConfig.getCaCertificateAliases();
1058                 if (caCerts == null) {
1059                     setSelection(mEapCaCertSpinner, mDoNotValidateEapServerString);
1060                 } else if (caCerts.length == 1) {
1061                     setSelection(mEapCaCertSpinner, caCerts[0]);
1062                 } else {
1063                     // Reload the cert spinner with an extra "multiple certificates added" item.
1064                     loadCertificates(
1065                             mEapCaCertSpinner,
1066                             Credentials.CA_CERTIFICATE,
1067                             mDoNotValidateEapServerString,
1068                             true,
1069                             true);
1070                     setSelection(mEapCaCertSpinner, mMultipleCertSetString);
1071                 }
1072             }
1073             mEapDomainView.setText(enterpriseConfig.getDomainSuffixMatch());
1074             final String userCert = enterpriseConfig.getClientCertificateAlias();
1075             if (TextUtils.isEmpty(userCert)) {
1076                 setSelection(mEapUserCertSpinner, mDoNotProvideEapUserCertString);
1077             } else {
1078                 setSelection(mEapUserCertSpinner, userCert);
1079             }
1080             mEapIdentityView.setText(enterpriseConfig.getIdentity());
1081             mEapAnonymousView.setText(enterpriseConfig.getAnonymousIdentity());
1082         } else {
1083             showEapFieldsByMethod(mEapMethodSpinner.getSelectedItemPosition());
1084         }
1085     }
1086
1087     /**
1088      * EAP-PWD valid fields include
1089      *   identity
1090      *   password
1091      * EAP-PEAP valid fields include
1092      *   phase2: MSCHAPV2, GTC, SIM, AKA, AKA'
1093      *   ca_cert
1094      *   identity
1095      *   anonymous_identity
1096      *   password (not required for SIM, AKA, AKA')
1097      * EAP-TLS valid fields include
1098      *   user_cert
1099      *   ca_cert
1100      *   domain
1101      *   identity
1102      * EAP-TTLS valid fields include
1103      *   phase2: PAP, MSCHAP, MSCHAPV2, GTC
1104      *   ca_cert
1105      *   identity
1106      *   anonymous_identity
1107      *   password
1108      */
1109     private void showEapFieldsByMethod(int eapMethod) {
1110         // Common defaults
1111         mView.findViewById(R.id.l_method).setVisibility(View.VISIBLE);
1112         mView.findViewById(R.id.l_identity).setVisibility(View.VISIBLE);
1113         mView.findViewById(R.id.l_domain).setVisibility(View.VISIBLE);
1114
1115         // Defaults for most of the EAP methods and over-riden by
1116         // by certain EAP methods
1117         mView.findViewById(R.id.l_ca_cert).setVisibility(View.VISIBLE);
1118         mView.findViewById(R.id.password_layout).setVisibility(View.VISIBLE);
1119         mView.findViewById(R.id.show_password_layout).setVisibility(View.VISIBLE);
1120
1121         Context context = mConfigUi.getContext();
1122         switch (eapMethod) {
1123             case WIFI_EAP_METHOD_PWD:
1124                 setPhase2Invisible();
1125                 setCaCertInvisible();
1126                 setDomainInvisible();
1127                 setAnonymousIdentInvisible();
1128                 setUserCertInvisible();
1129                 break;
1130             case WIFI_EAP_METHOD_TLS:
1131                 mView.findViewById(R.id.l_user_cert).setVisibility(View.VISIBLE);
1132                 setPhase2Invisible();
1133                 setAnonymousIdentInvisible();
1134                 setPasswordInvisible();
1135                 break;
1136             case WIFI_EAP_METHOD_PEAP:
1137                 // Reset adapter if needed
1138                 if (mPhase2Adapter != mPhase2PeapAdapter) {
1139                     mPhase2Adapter = mPhase2PeapAdapter;
1140                     mPhase2Spinner.setAdapter(mPhase2Adapter);
1141                 }
1142                 mView.findViewById(R.id.l_phase2).setVisibility(View.VISIBLE);
1143                 mView.findViewById(R.id.l_anonymous).setVisibility(View.VISIBLE);
1144                 showPeapFields();
1145                 setUserCertInvisible();
1146                 break;
1147             case WIFI_EAP_METHOD_TTLS:
1148                 // Reset adapter if needed
1149                 if (mPhase2Adapter != mPhase2FullAdapter) {
1150                     mPhase2Adapter = mPhase2FullAdapter;
1151                     mPhase2Spinner.setAdapter(mPhase2Adapter);
1152                 }
1153                 mView.findViewById(R.id.l_phase2).setVisibility(View.VISIBLE);
1154                 mView.findViewById(R.id.l_anonymous).setVisibility(View.VISIBLE);
1155                 setUserCertInvisible();
1156                 break;
1157             case WIFI_EAP_METHOD_SIM:
1158             case WIFI_EAP_METHOD_AKA:
1159             case WIFI_EAP_METHOD_AKA_PRIME:
1160                 setPhase2Invisible();
1161                 setAnonymousIdentInvisible();
1162                 setCaCertInvisible();
1163                 setDomainInvisible();
1164                 setUserCertInvisible();
1165                 setPasswordInvisible();
1166                 setIdentityInvisible();
1167                 if (mAccessPoint != null && mAccessPoint.isCarrierAp()) {
1168                     setEapMethodInvisible();
1169                 }
1170                 break;
1171         }
1172
1173         if (mView.findViewById(R.id.l_ca_cert).getVisibility() != View.GONE) {
1174             String eapCertSelection = (String) mEapCaCertSpinner.getSelectedItem();
1175             if (eapCertSelection.equals(mDoNotValidateEapServerString)
1176                     || eapCertSelection.equals(mUnspecifiedCertString)) {
1177                 // Domain suffix matching is not relevant if the user hasn't chosen a CA
1178                 // certificate yet, or chooses not to validate the EAP server.
1179                 setDomainInvisible();
1180             }
1181         }
1182     }
1183
1184     private void showPeapFields() {
1185         int phase2Method = mPhase2Spinner.getSelectedItemPosition();
1186         if (phase2Method == WIFI_PEAP_PHASE2_SIM || phase2Method == WIFI_PEAP_PHASE2_AKA
1187                  || phase2Method == WIFI_PEAP_PHASE2_AKA_PRIME) {
1188             mEapIdentityView.setText("");
1189             mView.findViewById(R.id.l_identity).setVisibility(View.GONE);
1190             setPasswordInvisible();
1191         } else {
1192             mView.findViewById(R.id.l_identity).setVisibility(View.VISIBLE);
1193             mView.findViewById(R.id.l_anonymous).setVisibility(View.VISIBLE);
1194             mView.findViewById(R.id.password_layout).setVisibility(View.VISIBLE);
1195             mView.findViewById(R.id.show_password_layout).setVisibility(View.VISIBLE);
1196         }
1197     }
1198
1199     private void setIdentityInvisible() {
1200         mView.findViewById(R.id.l_identity).setVisibility(View.GONE);
1201         mPhase2Spinner.setSelection(Phase2.NONE);
1202     }
1203
1204     private void setPhase2Invisible() {
1205         mView.findViewById(R.id.l_phase2).setVisibility(View.GONE);
1206         mPhase2Spinner.setSelection(Phase2.NONE);
1207     }
1208
1209     private void setCaCertInvisible() {
1210         mView.findViewById(R.id.l_ca_cert).setVisibility(View.GONE);
1211         setSelection(mEapCaCertSpinner, mUnspecifiedCertString);
1212     }
1213
1214     private void setDomainInvisible() {
1215         mView.findViewById(R.id.l_domain).setVisibility(View.GONE);
1216         mEapDomainView.setText("");
1217     }
1218
1219     private void setUserCertInvisible() {
1220         mView.findViewById(R.id.l_user_cert).setVisibility(View.GONE);
1221         setSelection(mEapUserCertSpinner, mUnspecifiedCertString);
1222     }
1223
1224     private void setAnonymousIdentInvisible() {
1225         mView.findViewById(R.id.l_anonymous).setVisibility(View.GONE);
1226         mEapAnonymousView.setText("");
1227     }
1228
1229     private void setPasswordInvisible() {
1230         mPasswordView.setText("");
1231         mView.findViewById(R.id.password_layout).setVisibility(View.GONE);
1232         mView.findViewById(R.id.show_password_layout).setVisibility(View.GONE);
1233     }
1234
1235     private void setEapMethodInvisible() {
1236         mView.findViewById(R.id.eap).setVisibility(View.GONE);
1237     }
1238
1239     private void showIpConfigFields() {
1240         WifiConfiguration config = null;
1241
1242         mView.findViewById(R.id.ip_fields).setVisibility(View.VISIBLE);
1243
1244         if (mAccessPoint != null && mAccessPoint.isSaved()) {
1245             config = mAccessPoint.getConfig();
1246         }
1247
1248         if (mIpSettingsSpinner.getSelectedItemPosition() == STATIC_IP) {
1249             mView.findViewById(R.id.staticip).setVisibility(View.VISIBLE);
1250             if (mIpAddressView == null) {
1251                 mIpAddressView = (TextView) mView.findViewById(R.id.ipaddress);
1252                 mIpAddressView.addTextChangedListener(this);
1253                 mGatewayView = (TextView) mView.findViewById(R.id.gateway);
1254                 mGatewayView.addTextChangedListener(this);
1255                 mNetworkPrefixLengthView = (TextView) mView.findViewById(
1256                         R.id.network_prefix_length);
1257                 mNetworkPrefixLengthView.addTextChangedListener(this);
1258                 mDns1View = (TextView) mView.findViewById(R.id.dns1);
1259                 mDns1View.addTextChangedListener(this);
1260                 mDns2View = (TextView) mView.findViewById(R.id.dns2);
1261                 mDns2View.addTextChangedListener(this);
1262             }
1263             if (config != null) {
1264                 StaticIpConfiguration staticConfig = config.getStaticIpConfiguration();
1265                 if (staticConfig != null) {
1266                     if (staticConfig.ipAddress != null) {
1267                         mIpAddressView.setText(
1268                                 staticConfig.ipAddress.getAddress().getHostAddress());
1269                         mNetworkPrefixLengthView.setText(Integer.toString(staticConfig.ipAddress
1270                                 .getNetworkPrefixLength()));
1271                     }
1272
1273                     if (staticConfig.gateway != null) {
1274                         mGatewayView.setText(staticConfig.gateway.getHostAddress());
1275                     }
1276
1277                     Iterator<InetAddress> dnsIterator = staticConfig.dnsServers.iterator();
1278                     if (dnsIterator.hasNext()) {
1279                         mDns1View.setText(dnsIterator.next().getHostAddress());
1280                     }
1281                     if (dnsIterator.hasNext()) {
1282                         mDns2View.setText(dnsIterator.next().getHostAddress());
1283                     }
1284                 }
1285             }
1286         } else {
1287             mView.findViewById(R.id.staticip).setVisibility(View.GONE);
1288         }
1289     }
1290
1291     private void showProxyFields() {
1292         WifiConfiguration config = null;
1293
1294         mView.findViewById(R.id.proxy_settings_fields).setVisibility(View.VISIBLE);
1295
1296         if (mAccessPoint != null && mAccessPoint.isSaved()) {
1297             config = mAccessPoint.getConfig();
1298         }
1299
1300         if (mProxySettingsSpinner.getSelectedItemPosition() == PROXY_STATIC) {
1301             setVisibility(R.id.proxy_warning_limited_support, View.VISIBLE);
1302             setVisibility(R.id.proxy_fields, View.VISIBLE);
1303             setVisibility(R.id.proxy_pac_field, View.GONE);
1304             if (mProxyHostView == null) {
1305                 mProxyHostView = (TextView) mView.findViewById(R.id.proxy_hostname);
1306                 mProxyHostView.addTextChangedListener(this);
1307                 mProxyPortView = (TextView) mView.findViewById(R.id.proxy_port);
1308                 mProxyPortView.addTextChangedListener(this);
1309                 mProxyExclusionListView = (TextView) mView.findViewById(R.id.proxy_exclusionlist);
1310                 mProxyExclusionListView.addTextChangedListener(this);
1311             }
1312             if (config != null) {
1313                 ProxyInfo proxyProperties = config.getHttpProxy();
1314                 if (proxyProperties != null) {
1315                     mProxyHostView.setText(proxyProperties.getHost());
1316                     mProxyPortView.setText(Integer.toString(proxyProperties.getPort()));
1317                     mProxyExclusionListView.setText(proxyProperties.getExclusionListAsString());
1318                 }
1319             }
1320         } else if (mProxySettingsSpinner.getSelectedItemPosition() == PROXY_PAC) {
1321             setVisibility(R.id.proxy_warning_limited_support, View.GONE);
1322             setVisibility(R.id.proxy_fields, View.GONE);
1323             setVisibility(R.id.proxy_pac_field, View.VISIBLE);
1324
1325             if (mProxyPacView == null) {
1326                 mProxyPacView = (TextView) mView.findViewById(R.id.proxy_pac);
1327                 mProxyPacView.addTextChangedListener(this);
1328             }
1329             if (config != null) {
1330                 ProxyInfo proxyInfo = config.getHttpProxy();
1331                 if (proxyInfo != null) {
1332                     mProxyPacView.setText(proxyInfo.getPacFileUrl().toString());
1333                 }
1334             }
1335         } else {
1336             setVisibility(R.id.proxy_warning_limited_support, View.GONE);
1337             setVisibility(R.id.proxy_fields, View.GONE);
1338             setVisibility(R.id.proxy_pac_field, View.GONE);
1339         }
1340     }
1341
1342     private void setVisibility(int id, int visibility) {
1343         final View v = mView.findViewById(id);
1344         if (v != null) {
1345             v.setVisibility(visibility);
1346         }
1347     }
1348
1349     @VisibleForTesting
1350     KeyStore getKeyStore() {
1351         return KeyStore.getInstance();
1352     }
1353
1354     private void loadCertificates(
1355             Spinner spinner,
1356             String prefix,
1357             String noCertificateString,
1358             boolean showMultipleCerts,
1359             boolean showUsePreinstalledCertOption) {
1360         final Context context = mConfigUi.getContext();
1361
1362         ArrayList<String> certs = new ArrayList<String>();
1363         certs.add(mUnspecifiedCertString);
1364         if (showMultipleCerts) {
1365             certs.add(mMultipleCertSetString);
1366         }
1367         if (showUsePreinstalledCertOption) {
1368             certs.add(mUseSystemCertsString);
1369         }
1370         try {
1371             certs.addAll(
1372                 Arrays.asList(getKeyStore().list(prefix, android.os.Process.WIFI_UID)));
1373         } catch (Exception e) {
1374             Log.e(TAG, "can't get the certificate list from KeyStore");
1375         }
1376
1377         if (mAccessPointSecurity != AccessPoint.SECURITY_EAP_SUITE_B) {
1378             certs.add(noCertificateString);
1379         }
1380
1381         // If there are only mUnspecifiedCertString and one item to select, only shows the item
1382         if (certs.size() == 2) {
1383             certs.remove(mUnspecifiedCertString);
1384             spinner.setEnabled(false);
1385         } else {
1386             spinner.setEnabled(true);
1387         }
1388
1389         final ArrayAdapter<String> adapter = new ArrayAdapter<String>(
1390                 context, android.R.layout.simple_spinner_item,
1391                 certs.toArray(new String[certs.size()]));
1392         adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
1393         spinner.setAdapter(adapter);
1394     }
1395
1396     private void setSelection(Spinner spinner, String value) {
1397         if (value != null) {
1398             @SuppressWarnings("unchecked")
1399             ArrayAdapter<String> adapter = (ArrayAdapter<String>) spinner.getAdapter();
1400             for (int i = adapter.getCount() - 1; i >= 0; --i) {
1401                 if (value.equals(adapter.getItem(i))) {
1402                     spinner.setSelection(i);
1403                     break;
1404                 }
1405             }
1406         }
1407     }
1408
1409     public int getMode() {
1410         return mMode;
1411     }
1412
1413     @Override
1414     public void afterTextChanged(Editable s) {
1415         ThreadUtils.postOnMainThread(() -> {
1416             showWarningMessagesIfAppropriate();
1417             enableSubmitIfAppropriate();
1418         });
1419     }
1420
1421     @Override
1422     public void beforeTextChanged(CharSequence s, int start, int count, int after) {
1423         // work done in afterTextChanged
1424     }
1425
1426     @Override
1427     public void onTextChanged(CharSequence s, int start, int before, int count) {
1428         // work done in afterTextChanged
1429     }
1430
1431     @Override
1432     public boolean onEditorAction(TextView textView, int id, KeyEvent keyEvent) {
1433         if (textView == mPasswordView) {
1434             if (id == EditorInfo.IME_ACTION_DONE && isSubmittable()) {
1435                 mConfigUi.dispatchSubmit();
1436                 return true;
1437             }
1438         }
1439         return false;
1440     }
1441
1442     @Override
1443     public boolean onKey(View view, int keyCode, KeyEvent keyEvent) {
1444         if (view == mPasswordView) {
1445             if (keyCode == KeyEvent.KEYCODE_ENTER && isSubmittable()) {
1446                 mConfigUi.dispatchSubmit();
1447                 return true;
1448             }
1449         }
1450         return false;
1451     }
1452
1453     @Override
1454     public void onCheckedChanged(CompoundButton view, boolean isChecked) {
1455         if (view.getId() == R.id.show_password) {
1456             int pos = mPasswordView.getSelectionEnd();
1457             mPasswordView.setInputType(InputType.TYPE_CLASS_TEXT
1458                     | (isChecked ? InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD
1459                                  : InputType.TYPE_TEXT_VARIATION_PASSWORD));
1460             if (pos >= 0) {
1461                 ((EditText) mPasswordView).setSelection(pos);
1462             }
1463         } else if (view.getId() == R.id.wifi_advanced_togglebox) {
1464             final View advancedToggle = mView.findViewById(R.id.wifi_advanced_toggle);
1465             final int toggleVisibility;
1466             final int stringID;
1467             if (isChecked) {
1468                 toggleVisibility = View.VISIBLE;
1469                 stringID = R.string.wifi_advanced_toggle_description_expanded;
1470             } else {
1471                 toggleVisibility = View.GONE;
1472                 stringID = R.string.wifi_advanced_toggle_description_collapsed;
1473             }
1474             mView.findViewById(R.id.wifi_advanced_fields).setVisibility(toggleVisibility);
1475             advancedToggle.setContentDescription(mContext.getString(stringID));
1476         }
1477     }
1478
1479     @Override
1480     public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
1481         if (parent == mSecuritySpinner) {
1482             // Convert menu position to actual Wi-Fi security type
1483             mAccessPointSecurity = mSecurityInPosition[position];
1484             showSecurityFields(true /* refreshEapMethods */, true /* refreshCertificates */);
1485
1486             if (WifiDppUtils.isSupportEnrolleeQrCodeScanner(mContext, mAccessPointSecurity)) {
1487                 mSsidScanButton.setVisibility(View.VISIBLE);
1488             } else {
1489                 mSsidScanButton.setVisibility(View.GONE);
1490             }
1491         } else if (parent == mEapMethodSpinner) {
1492             showSecurityFields(false /* refreshEapMethods */, true /* refreshCertificates */);
1493         } else if (parent == mEapCaCertSpinner) {
1494             showSecurityFields(false /* refreshEapMethods */, false /* refreshCertificates */);
1495         } else if (parent == mPhase2Spinner
1496                 && mEapMethodSpinner.getSelectedItemPosition() == WIFI_EAP_METHOD_PEAP) {
1497             showPeapFields();
1498         } else if (parent == mProxySettingsSpinner) {
1499             showProxyFields();
1500         } else if (parent == mHiddenSettingsSpinner) {
1501             mHiddenWarningView.setVisibility(
1502                     position == NOT_HIDDEN_NETWORK
1503                             ? View.GONE
1504                             : View.VISIBLE);
1505             if (position == HIDDEN_NETWORK) {
1506                 mDialogContainer.post(() -> {
1507                   mDialogContainer.fullScroll(View.FOCUS_DOWN);
1508                 });
1509             }
1510         } else {
1511             showIpConfigFields();
1512         }
1513         showWarningMessagesIfAppropriate();
1514         enableSubmitIfAppropriate();
1515     }
1516
1517     @Override
1518     public void onNothingSelected(AdapterView<?> parent) {
1519         //
1520     }
1521
1522     /**
1523      * Make the characters of the password visible if show_password is checked.
1524      */
1525     public void updatePassword() {
1526         TextView passwdView = (TextView) mView.findViewById(R.id.password);
1527         passwdView.setInputType(InputType.TYPE_CLASS_TEXT
1528                 | (((CheckBox) mView.findViewById(R.id.show_password)).isChecked()
1529                    ? InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD
1530                    : InputType.TYPE_TEXT_VARIATION_PASSWORD));
1531     }
1532
1533     public AccessPoint getAccessPoint() {
1534         return mAccessPoint;
1535     }
1536
1537     private void configureSecuritySpinner() {
1538         mConfigUi.setTitle(R.string.wifi_add_network);
1539
1540         mSsidView = (TextView) mView.findViewById(R.id.ssid);
1541         mSsidView.addTextChangedListener(this);
1542         mSecuritySpinner = ((Spinner) mView.findViewById(R.id.security));
1543         mSecuritySpinner.setOnItemSelectedListener(this);
1544
1545         ArrayAdapter<String> spinnerAdapter = new ArrayAdapter<String>(mContext,
1546                 android.R.layout.simple_spinner_item, android.R.id.text1);
1547         spinnerAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
1548         mSecuritySpinner.setAdapter(spinnerAdapter);
1549         int idx = 0;
1550
1551         // Populate the Wi-Fi security spinner with the various supported key management types
1552         spinnerAdapter.add(mContext.getString(R.string.wifi_security_none));
1553         mSecurityInPosition[idx++] = AccessPoint.SECURITY_NONE;
1554         if (mWifiManager.isEnhancedOpenSupported()) {
1555             spinnerAdapter.add(mContext.getString(R.string.wifi_security_owe));
1556             mSecurityInPosition[idx++] = AccessPoint.SECURITY_OWE;
1557         }
1558         spinnerAdapter.add(mContext.getString(R.string.wifi_security_wep));
1559         mSecurityInPosition[idx++] = AccessPoint.SECURITY_WEP;
1560         spinnerAdapter.add(mContext.getString(R.string.wifi_security_wpa_wpa2));
1561         mSecurityInPosition[idx++] = AccessPoint.SECURITY_PSK;
1562         if (mWifiManager.isWpa3SaeSupported()) {
1563             spinnerAdapter.add(mContext.getString(R.string.wifi_security_sae));
1564             mSecurityInPosition[idx++] = AccessPoint.SECURITY_SAE;
1565         }
1566         spinnerAdapter.add(mContext.getString(R.string.wifi_security_eap));
1567         mSecurityInPosition[idx++] = AccessPoint.SECURITY_EAP;
1568         if (mWifiManager.isWpa3SuiteBSupported()) {
1569             spinnerAdapter.add(mContext.getString(R.string.wifi_security_eap_suiteb));
1570             mSecurityInPosition[idx++] = AccessPoint.SECURITY_EAP_SUITE_B;
1571         }
1572
1573         spinnerAdapter.notifyDataSetChanged();
1574
1575         mView.findViewById(R.id.type).setVisibility(View.VISIBLE);
1576
1577         showIpConfigFields();
1578         showProxyFields();
1579         mView.findViewById(R.id.wifi_advanced_toggle).setVisibility(View.VISIBLE);
1580         // Hidden option can be changed only when the user adds a network manually.
1581         mView.findViewById(R.id.hidden_settings_field).setVisibility(View.VISIBLE);
1582         ((CheckBox) mView.findViewById(R.id.wifi_advanced_togglebox))
1583                 .setOnCheckedChangeListener(this);
1584     }
1585
1586     private ArrayAdapter<CharSequence> getSpinnerAdapter(
1587             int contentStringArrayResId) {
1588         final String[] eapMethods = mContext.getResources().getStringArray(
1589                 contentStringArrayResId);
1590         final ArrayAdapter<CharSequence> spinnerAdapter = new ArrayAdapter<>(mContext,
1591                 android.R.layout.simple_spinner_item, eapMethods);
1592         spinnerAdapter.setDropDownViewResource(
1593                 android.R.layout.simple_spinner_dropdown_item);
1594         return spinnerAdapter;
1595     }
1596 }