83397eab96
When click Tethering, the checkbox will be checked and then unchecked, and finally move to checked states. This causes confusing to end user, we need to keep Tethering checkbox unchecked before tethering is really up. Change-Id: If2314b7dd1369e619dead45af38fd53c7e89c34e Author: Li Wenji <wenji.li@intel.com> Signed-off-by: Xiaokang Qin <xiaokang.qin@intel.com> Signed-off-by: Bruce Beare <bruce.j.beare@intel.com> Signed-off-by: Jack Ren <jack.ren@intel.com> Author-tracking-BZ: 18281
585 lines
22 KiB
Java
585 lines
22 KiB
Java
/*
|
|
* Copyright (C) 2008 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package com.android.settings;
|
|
|
|
import com.android.settings.wifi.WifiApEnabler;
|
|
import com.android.settings.wifi.WifiApDialog;
|
|
|
|
import android.app.Activity;
|
|
import android.app.AlertDialog;
|
|
import android.app.Dialog;
|
|
import android.bluetooth.BluetoothAdapter;
|
|
import android.bluetooth.BluetoothPan;
|
|
import android.bluetooth.BluetoothProfile;
|
|
import android.content.BroadcastReceiver;
|
|
import android.content.Context;
|
|
import android.content.DialogInterface;
|
|
import android.content.Intent;
|
|
import android.content.IntentFilter;
|
|
import android.content.res.AssetManager;
|
|
import android.hardware.usb.UsbManager;
|
|
import android.net.ConnectivityManager;
|
|
import android.net.wifi.WifiConfiguration;
|
|
import android.net.wifi.WifiManager;
|
|
import android.os.Bundle;
|
|
import android.os.Environment;
|
|
import android.os.SystemProperties;
|
|
import android.preference.CheckBoxPreference;
|
|
import android.preference.Preference;
|
|
import android.preference.PreferenceScreen;
|
|
import android.text.TextUtils;
|
|
import android.view.ViewGroup;
|
|
import android.view.ViewParent;
|
|
import android.webkit.WebView;
|
|
|
|
import java.io.InputStream;
|
|
import java.util.ArrayList;
|
|
import java.util.Locale;
|
|
|
|
/*
|
|
* Displays preferences for Tethering.
|
|
*/
|
|
public class TetherSettings extends SettingsPreferenceFragment
|
|
implements DialogInterface.OnClickListener, Preference.OnPreferenceChangeListener {
|
|
|
|
private static final String USB_TETHER_SETTINGS = "usb_tether_settings";
|
|
private static final String ENABLE_WIFI_AP = "enable_wifi_ap";
|
|
private static final String ENABLE_BLUETOOTH_TETHERING = "enable_bluetooth_tethering";
|
|
|
|
private static final int DIALOG_AP_SETTINGS = 1;
|
|
|
|
private WebView mView;
|
|
private CheckBoxPreference mUsbTether;
|
|
|
|
private WifiApEnabler mWifiApEnabler;
|
|
private CheckBoxPreference mEnableWifiAp;
|
|
|
|
private CheckBoxPreference mBluetoothTether;
|
|
|
|
private BroadcastReceiver mTetherChangeReceiver;
|
|
|
|
private String[] mUsbRegexs;
|
|
|
|
private String[] mWifiRegexs;
|
|
|
|
private String[] mBluetoothRegexs;
|
|
private BluetoothPan mBluetoothPan;
|
|
|
|
private static final String WIFI_AP_SSID_AND_SECURITY = "wifi_ap_ssid_and_security";
|
|
private static final int CONFIG_SUBTEXT = R.string.wifi_tether_configure_subtext;
|
|
|
|
private String[] mSecurityType;
|
|
private Preference mCreateNetwork;
|
|
|
|
private WifiApDialog mDialog;
|
|
private WifiManager mWifiManager;
|
|
private WifiConfiguration mWifiConfig = null;
|
|
|
|
private boolean mUsbConnected;
|
|
private boolean mMassStorageActive;
|
|
|
|
private boolean mBluetoothEnableForTether;
|
|
|
|
private static final int INVALID = -1;
|
|
private static final int WIFI_TETHERING = 0;
|
|
private static final int USB_TETHERING = 1;
|
|
private static final int BLUETOOTH_TETHERING = 2;
|
|
|
|
/* One of INVALID, WIFI_TETHERING, USB_TETHERING or BLUETOOTH_TETHERING */
|
|
private int mTetherChoice = INVALID;
|
|
|
|
/* Stores the package name and the class name of the provisioning app */
|
|
private String[] mProvisionApp;
|
|
private static final int PROVISION_REQUEST = 0;
|
|
|
|
@Override
|
|
public void onCreate(Bundle icicle) {
|
|
super.onCreate(icicle);
|
|
addPreferencesFromResource(R.xml.tether_prefs);
|
|
|
|
final Activity activity = getActivity();
|
|
BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
|
|
if (adapter != null) {
|
|
adapter.getProfileProxy(activity.getApplicationContext(), mProfileServiceListener,
|
|
BluetoothProfile.PAN);
|
|
}
|
|
|
|
mEnableWifiAp =
|
|
(CheckBoxPreference) findPreference(ENABLE_WIFI_AP);
|
|
Preference wifiApSettings = findPreference(WIFI_AP_SSID_AND_SECURITY);
|
|
mUsbTether = (CheckBoxPreference) findPreference(USB_TETHER_SETTINGS);
|
|
mBluetoothTether = (CheckBoxPreference) findPreference(ENABLE_BLUETOOTH_TETHERING);
|
|
|
|
ConnectivityManager cm =
|
|
(ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
|
|
|
|
mUsbRegexs = cm.getTetherableUsbRegexs();
|
|
mWifiRegexs = cm.getTetherableWifiRegexs();
|
|
mBluetoothRegexs = cm.getTetherableBluetoothRegexs();
|
|
|
|
final boolean usbAvailable = mUsbRegexs.length != 0;
|
|
final boolean wifiAvailable = mWifiRegexs.length != 0;
|
|
final boolean bluetoothAvailable = mBluetoothRegexs.length != 0;
|
|
|
|
if (!usbAvailable || Utils.isMonkeyRunning()) {
|
|
getPreferenceScreen().removePreference(mUsbTether);
|
|
}
|
|
|
|
if (wifiAvailable && !Utils.isMonkeyRunning()) {
|
|
mWifiApEnabler = new WifiApEnabler(activity, mEnableWifiAp);
|
|
initWifiTethering();
|
|
} else {
|
|
getPreferenceScreen().removePreference(mEnableWifiAp);
|
|
getPreferenceScreen().removePreference(wifiApSettings);
|
|
}
|
|
|
|
if (!bluetoothAvailable) {
|
|
getPreferenceScreen().removePreference(mBluetoothTether);
|
|
} else {
|
|
if (mBluetoothPan != null && mBluetoothPan.isTetheringOn()) {
|
|
mBluetoothTether.setChecked(true);
|
|
} else {
|
|
mBluetoothTether.setChecked(false);
|
|
}
|
|
}
|
|
|
|
mProvisionApp = getResources().getStringArray(
|
|
com.android.internal.R.array.config_mobile_hotspot_provision_app);
|
|
|
|
mView = new WebView(activity);
|
|
}
|
|
|
|
private void initWifiTethering() {
|
|
final Activity activity = getActivity();
|
|
mWifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE);
|
|
mWifiConfig = mWifiManager.getWifiApConfiguration();
|
|
mSecurityType = getResources().getStringArray(R.array.wifi_ap_security);
|
|
|
|
mCreateNetwork = findPreference(WIFI_AP_SSID_AND_SECURITY);
|
|
|
|
if (mWifiConfig == null) {
|
|
final String s = activity.getString(
|
|
com.android.internal.R.string.wifi_tether_configure_ssid_default);
|
|
mCreateNetwork.setSummary(String.format(activity.getString(CONFIG_SUBTEXT),
|
|
s, mSecurityType[WifiApDialog.OPEN_INDEX]));
|
|
} else {
|
|
int index = WifiApDialog.getSecurityTypeIndex(mWifiConfig);
|
|
mCreateNetwork.setSummary(String.format(activity.getString(CONFIG_SUBTEXT),
|
|
mWifiConfig.SSID,
|
|
mSecurityType[index]));
|
|
}
|
|
}
|
|
|
|
private BluetoothProfile.ServiceListener mProfileServiceListener =
|
|
new BluetoothProfile.ServiceListener() {
|
|
public void onServiceConnected(int profile, BluetoothProfile proxy) {
|
|
mBluetoothPan = (BluetoothPan) proxy;
|
|
}
|
|
public void onServiceDisconnected(int profile) {
|
|
mBluetoothPan = null;
|
|
}
|
|
};
|
|
|
|
@Override
|
|
public Dialog onCreateDialog(int id) {
|
|
if (id == DIALOG_AP_SETTINGS) {
|
|
final Activity activity = getActivity();
|
|
mDialog = new WifiApDialog(activity, this, mWifiConfig);
|
|
return mDialog;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private class TetherChangeReceiver extends BroadcastReceiver {
|
|
@Override
|
|
public void onReceive(Context content, Intent intent) {
|
|
String action = intent.getAction();
|
|
if (action.equals(ConnectivityManager.ACTION_TETHER_STATE_CHANGED)) {
|
|
// TODO - this should understand the interface types
|
|
ArrayList<String> available = intent.getStringArrayListExtra(
|
|
ConnectivityManager.EXTRA_AVAILABLE_TETHER);
|
|
ArrayList<String> active = intent.getStringArrayListExtra(
|
|
ConnectivityManager.EXTRA_ACTIVE_TETHER);
|
|
ArrayList<String> errored = intent.getStringArrayListExtra(
|
|
ConnectivityManager.EXTRA_ERRORED_TETHER);
|
|
updateState(available.toArray(new String[available.size()]),
|
|
active.toArray(new String[active.size()]),
|
|
errored.toArray(new String[errored.size()]));
|
|
} else if (action.equals(Intent.ACTION_MEDIA_SHARED)) {
|
|
mMassStorageActive = true;
|
|
updateState();
|
|
} else if (action.equals(Intent.ACTION_MEDIA_UNSHARED)) {
|
|
mMassStorageActive = false;
|
|
updateState();
|
|
} else if (action.equals(UsbManager.ACTION_USB_STATE)) {
|
|
mUsbConnected = intent.getBooleanExtra(UsbManager.USB_CONNECTED, false);
|
|
updateState();
|
|
} else if (action.equals(BluetoothAdapter.ACTION_STATE_CHANGED)) {
|
|
if (mBluetoothEnableForTether) {
|
|
switch (intent
|
|
.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.ERROR)) {
|
|
case BluetoothAdapter.STATE_ON:
|
|
mBluetoothPan.setBluetoothTethering(true);
|
|
mBluetoothEnableForTether = false;
|
|
break;
|
|
|
|
case BluetoothAdapter.STATE_OFF:
|
|
case BluetoothAdapter.ERROR:
|
|
mBluetoothEnableForTether = false;
|
|
break;
|
|
|
|
default:
|
|
// ignore transition states
|
|
}
|
|
}
|
|
updateState();
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onStart() {
|
|
super.onStart();
|
|
|
|
final Activity activity = getActivity();
|
|
|
|
mMassStorageActive = Environment.MEDIA_SHARED.equals(Environment.getExternalStorageState());
|
|
mTetherChangeReceiver = new TetherChangeReceiver();
|
|
IntentFilter filter = new IntentFilter(ConnectivityManager.ACTION_TETHER_STATE_CHANGED);
|
|
Intent intent = activity.registerReceiver(mTetherChangeReceiver, filter);
|
|
|
|
filter = new IntentFilter();
|
|
filter.addAction(UsbManager.ACTION_USB_STATE);
|
|
activity.registerReceiver(mTetherChangeReceiver, filter);
|
|
|
|
filter = new IntentFilter();
|
|
filter.addAction(Intent.ACTION_MEDIA_SHARED);
|
|
filter.addAction(Intent.ACTION_MEDIA_UNSHARED);
|
|
filter.addDataScheme("file");
|
|
activity.registerReceiver(mTetherChangeReceiver, filter);
|
|
|
|
filter = new IntentFilter();
|
|
filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
|
|
activity.registerReceiver(mTetherChangeReceiver, filter);
|
|
|
|
if (intent != null) mTetherChangeReceiver.onReceive(activity, intent);
|
|
if (mWifiApEnabler != null) {
|
|
mEnableWifiAp.setOnPreferenceChangeListener(this);
|
|
mWifiApEnabler.resume();
|
|
}
|
|
|
|
updateState();
|
|
}
|
|
|
|
@Override
|
|
public void onStop() {
|
|
super.onStop();
|
|
getActivity().unregisterReceiver(mTetherChangeReceiver);
|
|
mTetherChangeReceiver = null;
|
|
if (mWifiApEnabler != null) {
|
|
mEnableWifiAp.setOnPreferenceChangeListener(null);
|
|
mWifiApEnabler.pause();
|
|
}
|
|
}
|
|
|
|
private void updateState() {
|
|
ConnectivityManager cm =
|
|
(ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
|
|
|
|
String[] available = cm.getTetherableIfaces();
|
|
String[] tethered = cm.getTetheredIfaces();
|
|
String[] errored = cm.getTetheringErroredIfaces();
|
|
updateState(available, tethered, errored);
|
|
}
|
|
|
|
private void updateState(String[] available, String[] tethered,
|
|
String[] errored) {
|
|
updateUsbState(available, tethered, errored);
|
|
updateBluetoothState(available, tethered, errored);
|
|
}
|
|
|
|
|
|
private void updateUsbState(String[] available, String[] tethered,
|
|
String[] errored) {
|
|
ConnectivityManager cm =
|
|
(ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
|
|
boolean usbAvailable = mUsbConnected && !mMassStorageActive;
|
|
int usbError = ConnectivityManager.TETHER_ERROR_NO_ERROR;
|
|
for (String s : available) {
|
|
for (String regex : mUsbRegexs) {
|
|
if (s.matches(regex)) {
|
|
if (usbError == ConnectivityManager.TETHER_ERROR_NO_ERROR) {
|
|
usbError = cm.getLastTetherError(s);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
boolean usbTethered = false;
|
|
for (String s : tethered) {
|
|
for (String regex : mUsbRegexs) {
|
|
if (s.matches(regex)) usbTethered = true;
|
|
}
|
|
}
|
|
boolean usbErrored = false;
|
|
for (String s: errored) {
|
|
for (String regex : mUsbRegexs) {
|
|
if (s.matches(regex)) usbErrored = true;
|
|
}
|
|
}
|
|
|
|
if (usbTethered) {
|
|
mUsbTether.setSummary(R.string.usb_tethering_active_subtext);
|
|
mUsbTether.setEnabled(true);
|
|
mUsbTether.setChecked(true);
|
|
} else if (usbAvailable) {
|
|
if (usbError == ConnectivityManager.TETHER_ERROR_NO_ERROR) {
|
|
mUsbTether.setSummary(R.string.usb_tethering_available_subtext);
|
|
} else {
|
|
mUsbTether.setSummary(R.string.usb_tethering_errored_subtext);
|
|
}
|
|
mUsbTether.setEnabled(true);
|
|
mUsbTether.setChecked(false);
|
|
} else if (usbErrored) {
|
|
mUsbTether.setSummary(R.string.usb_tethering_errored_subtext);
|
|
mUsbTether.setEnabled(false);
|
|
mUsbTether.setChecked(false);
|
|
} else if (mMassStorageActive) {
|
|
mUsbTether.setSummary(R.string.usb_tethering_storage_active_subtext);
|
|
mUsbTether.setEnabled(false);
|
|
mUsbTether.setChecked(false);
|
|
} else {
|
|
mUsbTether.setSummary(R.string.usb_tethering_unavailable_subtext);
|
|
mUsbTether.setEnabled(false);
|
|
mUsbTether.setChecked(false);
|
|
}
|
|
}
|
|
|
|
private void updateBluetoothState(String[] available, String[] tethered,
|
|
String[] errored) {
|
|
int bluetoothTethered = 0;
|
|
for (String s : tethered) {
|
|
for (String regex : mBluetoothRegexs) {
|
|
if (s.matches(regex)) bluetoothTethered++;
|
|
}
|
|
}
|
|
boolean bluetoothErrored = false;
|
|
for (String s: errored) {
|
|
for (String regex : mBluetoothRegexs) {
|
|
if (s.matches(regex)) bluetoothErrored = true;
|
|
}
|
|
}
|
|
|
|
BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
|
|
int btState = adapter.getState();
|
|
if (btState == BluetoothAdapter.STATE_TURNING_OFF) {
|
|
mBluetoothTether.setEnabled(false);
|
|
mBluetoothTether.setSummary(R.string.wifi_stopping);
|
|
} else if (btState == BluetoothAdapter.STATE_TURNING_ON) {
|
|
mBluetoothTether.setEnabled(false);
|
|
mBluetoothTether.setSummary(R.string.bluetooth_turning_on);
|
|
} else if (btState == BluetoothAdapter.STATE_ON && mBluetoothPan.isTetheringOn()) {
|
|
mBluetoothTether.setChecked(true);
|
|
mBluetoothTether.setEnabled(true);
|
|
if (bluetoothTethered > 1) {
|
|
String summary = getString(
|
|
R.string.bluetooth_tethering_devices_connected_subtext, bluetoothTethered);
|
|
mBluetoothTether.setSummary(summary);
|
|
} else if (bluetoothTethered == 1) {
|
|
mBluetoothTether.setSummary(R.string.bluetooth_tethering_device_connected_subtext);
|
|
} else if (bluetoothErrored) {
|
|
mBluetoothTether.setSummary(R.string.bluetooth_tethering_errored_subtext);
|
|
} else {
|
|
mBluetoothTether.setSummary(R.string.bluetooth_tethering_available_subtext);
|
|
}
|
|
} else {
|
|
mBluetoothTether.setEnabled(true);
|
|
mBluetoothTether.setChecked(false);
|
|
mBluetoothTether.setSummary(R.string.bluetooth_tethering_off_subtext);
|
|
}
|
|
}
|
|
|
|
public boolean onPreferenceChange(Preference preference, Object value) {
|
|
boolean enable = (Boolean) value;
|
|
|
|
if (enable) {
|
|
startProvisioningIfNecessary(WIFI_TETHERING);
|
|
} else {
|
|
mWifiApEnabler.setSoftapEnabled(false);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
boolean isProvisioningNeeded() {
|
|
if (SystemProperties.getBoolean("net.tethering.noprovisioning", false)) {
|
|
return false;
|
|
}
|
|
return mProvisionApp.length == 2;
|
|
}
|
|
|
|
private void startProvisioningIfNecessary(int choice) {
|
|
mTetherChoice = choice;
|
|
if (isProvisioningNeeded()) {
|
|
Intent intent = new Intent(Intent.ACTION_MAIN);
|
|
intent.setClassName(mProvisionApp[0], mProvisionApp[1]);
|
|
startActivityForResult(intent, PROVISION_REQUEST);
|
|
} else {
|
|
startTethering();
|
|
}
|
|
}
|
|
|
|
public void onActivityResult(int requestCode, int resultCode, Intent intent) {
|
|
super.onActivityResult(requestCode, resultCode, intent);
|
|
if (requestCode == PROVISION_REQUEST) {
|
|
if (resultCode == Activity.RESULT_OK) {
|
|
startTethering();
|
|
} else {
|
|
//BT and USB need checkbox turned off on failure
|
|
//Wifi tethering is never turned on until afterwards
|
|
switch (mTetherChoice) {
|
|
case BLUETOOTH_TETHERING:
|
|
mBluetoothTether.setChecked(false);
|
|
break;
|
|
case USB_TETHERING:
|
|
mUsbTether.setChecked(false);
|
|
break;
|
|
}
|
|
mTetherChoice = INVALID;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void startTethering() {
|
|
switch (mTetherChoice) {
|
|
case WIFI_TETHERING:
|
|
mWifiApEnabler.setSoftapEnabled(true);
|
|
break;
|
|
case BLUETOOTH_TETHERING:
|
|
// turn on Bluetooth first
|
|
BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
|
|
if (adapter.getState() == BluetoothAdapter.STATE_OFF) {
|
|
mBluetoothEnableForTether = true;
|
|
adapter.enable();
|
|
mBluetoothTether.setSummary(R.string.bluetooth_turning_on);
|
|
mBluetoothTether.setEnabled(false);
|
|
} else {
|
|
mBluetoothPan.setBluetoothTethering(true);
|
|
mBluetoothTether.setSummary(R.string.bluetooth_tethering_available_subtext);
|
|
}
|
|
break;
|
|
case USB_TETHERING:
|
|
setUsbTethering(true);
|
|
break;
|
|
default:
|
|
//should not happen
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void setUsbTethering(boolean enabled) {
|
|
ConnectivityManager cm =
|
|
(ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
|
|
mUsbTether.setChecked(false);
|
|
if (cm.setUsbTethering(enabled) != ConnectivityManager.TETHER_ERROR_NO_ERROR) {
|
|
mUsbTether.setSummary(R.string.usb_tethering_errored_subtext);
|
|
return;
|
|
}
|
|
mUsbTether.setSummary("");
|
|
}
|
|
|
|
@Override
|
|
public boolean onPreferenceTreeClick(PreferenceScreen screen, Preference preference) {
|
|
ConnectivityManager cm =
|
|
(ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
|
|
|
|
if (preference == mUsbTether) {
|
|
boolean newState = mUsbTether.isChecked();
|
|
|
|
if (newState) {
|
|
startProvisioningIfNecessary(USB_TETHERING);
|
|
} else {
|
|
setUsbTethering(newState);
|
|
}
|
|
} else if (preference == mBluetoothTether) {
|
|
boolean bluetoothTetherState = mBluetoothTether.isChecked();
|
|
|
|
if (bluetoothTetherState) {
|
|
startProvisioningIfNecessary(BLUETOOTH_TETHERING);
|
|
} else {
|
|
boolean errored = false;
|
|
|
|
String [] tethered = cm.getTetheredIfaces();
|
|
String bluetoothIface = findIface(tethered, mBluetoothRegexs);
|
|
if (bluetoothIface != null &&
|
|
cm.untether(bluetoothIface) != ConnectivityManager.TETHER_ERROR_NO_ERROR) {
|
|
errored = true;
|
|
}
|
|
|
|
mBluetoothPan.setBluetoothTethering(false);
|
|
if (errored) {
|
|
mBluetoothTether.setSummary(R.string.bluetooth_tethering_errored_subtext);
|
|
} else {
|
|
mBluetoothTether.setSummary(R.string.bluetooth_tethering_off_subtext);
|
|
}
|
|
}
|
|
} else if (preference == mCreateNetwork) {
|
|
showDialog(DIALOG_AP_SETTINGS);
|
|
}
|
|
|
|
return super.onPreferenceTreeClick(screen, preference);
|
|
}
|
|
|
|
private static String findIface(String[] ifaces, String[] regexes) {
|
|
for (String iface : ifaces) {
|
|
for (String regex : regexes) {
|
|
if (iface.matches(regex)) {
|
|
return iface;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public void onClick(DialogInterface dialogInterface, int button) {
|
|
if (button == DialogInterface.BUTTON_POSITIVE) {
|
|
mWifiConfig = mDialog.getConfig();
|
|
if (mWifiConfig != null) {
|
|
/**
|
|
* if soft AP is stopped, bring up
|
|
* else restart with new config
|
|
* TODO: update config on a running access point when framework support is added
|
|
*/
|
|
if (mWifiManager.getWifiApState() == WifiManager.WIFI_AP_STATE_ENABLED) {
|
|
mWifiManager.setWifiApEnabled(null, false);
|
|
mWifiManager.setWifiApEnabled(mWifiConfig, true);
|
|
} else {
|
|
mWifiManager.setWifiApConfiguration(mWifiConfig);
|
|
}
|
|
int index = WifiApDialog.getSecurityTypeIndex(mWifiConfig);
|
|
mCreateNetwork.setSummary(String.format(getActivity().getString(CONFIG_SUBTEXT),
|
|
mWifiConfig.SSID,
|
|
mSecurityType[index]));
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public int getHelpResource() {
|
|
return R.string.help_url_tether;
|
|
}
|
|
}
|