package com.android.settings;
+import com.android.settings.wifi.WifiApEnabler;
+
+import android.app.AlertDialog;
+import android.app.Dialog;
import android.os.Bundle;
import android.os.SystemProperties;
import android.content.BroadcastReceiver;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
+import android.os.Environment;
+import android.preference.CheckBoxPreference;
import android.preference.Preference;
import android.preference.PreferenceActivity;
import android.preference.PreferenceScreen;
-import android.preference.CheckBoxPreference;
import android.provider.Settings;
import android.util.Log;
+import android.webkit.WebView;
+
+import java.util.ArrayList;
+import java.util.Locale;
/*
* Displays preferences for Tethering.
*/
public class TetherSettings extends PreferenceActivity {
-
- private static final String ENABLE_TETHER_NOTICE = "enable_tether_notice";
private static final String USB_TETHER_SETTINGS = "usb_tether_settings";
+ private static final String ENABLE_WIFI_AP = "enable_wifi_ap";
+ private static final String WIFI_AP_SETTINGS = "wifi_ap_settings";
+ private static final String TETHERING_HELP = "tethering_help";
+ private static final String USB_HELP_MODIFIER = "usb_";
+ private static final String WIFI_HELP_MODIFIER = "wifi_";
+ private static final String HELP_URL = "file:///android_asset/html/%y_%z/tethering_%xhelp.html";
+
+ private static final int DIALOG_TETHER_HELP = 1;
- private CheckBoxPreference mEnableTetherNotice;
- private PreferenceScreen mUsbTether;
+ private WebView mView;
+ private CheckBoxPreference mUsbTether;
+
+ private CheckBoxPreference mEnableWifiAp;
+ private PreferenceScreen mWifiApSettings;
+ private WifiApEnabler mWifiApEnabler;
+ private PreferenceScreen mTetherHelp;
private BroadcastReceiver mTetherChangeReceiver;
+ private String[] mUsbRegexs;
+ private ArrayList mUsbIfaces;
+
+ private String[] mWifiRegexs;
+
@Override
protected void onCreate(Bundle icicle) {
super.onCreate(icicle);
addPreferencesFromResource(R.xml.tether_prefs);
- mEnableTetherNotice = (CheckBoxPreference) findPreference(ENABLE_TETHER_NOTICE);
- mUsbTether = (PreferenceScreen) findPreference(USB_TETHER_SETTINGS);
+ mEnableWifiAp = (CheckBoxPreference) findPreference(ENABLE_WIFI_AP);
+ mWifiApSettings = (PreferenceScreen) findPreference(WIFI_AP_SETTINGS);
+ mUsbTether = (CheckBoxPreference) findPreference(USB_TETHER_SETTINGS);
+ mTetherHelp = (PreferenceScreen) findPreference(TETHERING_HELP);
+
+ ConnectivityManager cm =
+ (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
+
+ mUsbRegexs = cm.getTetherableUsbRegexs();
+ if (mUsbRegexs.length == 0) {
+ getPreferenceScreen().removePreference(mUsbTether);
+ }
+
+ mWifiRegexs = cm.getTetherableWifiRegexs();
+ if (mWifiRegexs.length == 0) {
+ getPreferenceScreen().removePreference(mEnableWifiAp);
+ getPreferenceScreen().removePreference(mWifiApSettings);
+ }
+ mWifiApEnabler = new WifiApEnabler(this, mEnableWifiAp);
+ mView = new WebView(this);
+ }
+
+ @Override
+ protected Dialog onCreateDialog(int id) {
+ if (id == DIALOG_TETHER_HELP) {
+ Locale locale = Locale.getDefault();
+ String url = HELP_URL.replace("%y", locale.getLanguage().toLowerCase());
+ url = url.replace("%z", locale.getCountry().toLowerCase());
+
+ if ((mUsbRegexs.length != 0) && (mWifiRegexs.length == 0)) {
+ url = url.replace("%x", USB_HELP_MODIFIER);
+ } else if ((mWifiRegexs.length != 0) && (mUsbRegexs.length == 0)) {
+ url = url.replace("%x", WIFI_HELP_MODIFIER);
+ } else {
+ // could assert that both wifi and usb have regexs, but the default
+ // is to use this anyway so no check is needed
+ url = url.replace("%x", "");
+ }
+ mView.loadUrl(url);
+
+ return new AlertDialog.Builder(this)
+ .setCancelable(true)
+ .setTitle(R.string.tethering_help_button_text)
+ .setView(mView)
+ .create();
+ }
+ return null;
}
private class TetherChangeReceiver extends BroadcastReceiver {
public void onReceive(Context content, Intent intent) {
- updateState(intent.getIntExtra(ConnectivityManager.EXTRA_AVAILABLE_TETHER_COUNT,0)>0,
- intent.getIntExtra(ConnectivityManager.EXTRA_ACTIVE_TETHER_COUNT,0)>0);
+ if (intent.getAction().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(), active.toArray(), errored.toArray());
+ } else if (intent.getAction().equals(Intent.ACTION_MEDIA_SHARED) ||
+ intent.getAction().equals(Intent.ACTION_MEDIA_UNSHARED)) {
+ updateState();
+ }
}
}
@Override
protected void onResume() {
super.onResume();
- mEnableTetherNotice.setChecked(Settings.Secure.getInt(getContentResolver(),
- Settings.Secure.TETHER_NOTIFY, 0) != 0);
IntentFilter filter = new IntentFilter(ConnectivityManager.ACTION_TETHER_STATE_CHANGED);
mTetherChangeReceiver = new TetherChangeReceiver();
+ Intent intent = registerReceiver(mTetherChangeReceiver, filter);
+
+ filter = new IntentFilter();
+ filter.addAction(Intent.ACTION_MEDIA_SHARED);
+ filter.addAction(Intent.ACTION_MEDIA_UNSHARED);
+ filter.addDataScheme("file");
registerReceiver(mTetherChangeReceiver, filter);
- ConnectivityManager cm =
- (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
- updateState(cm.getTetherableIfaces().length>0, cm.getTetheredIfaces().length>0);
+ if (intent != null) mTetherChangeReceiver.onReceive(this, intent);
+ mWifiApEnabler.resume();
}
@Override
super.onPause();
unregisterReceiver(mTetherChangeReceiver);
mTetherChangeReceiver = null;
+ mWifiApEnabler.pause();
}
- private void updateState(boolean isAvailable, boolean isTethered) {
- if (isTethered) {
+ 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(Object[] available, Object[] tethered,
+ Object[] errored) {
+ ConnectivityManager cm =
+ (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
+ boolean usbTethered = false;
+ boolean usbAvailable = false;
+ int usbError = ConnectivityManager.TETHER_ERROR_NO_ERROR;
+ boolean usbErrored = false;
+ boolean massStorageActive =
+ Environment.MEDIA_SHARED.equals(Environment.getExternalStorageState());
+ for (Object o : available) {
+ String s = (String)o;
+ for (String regex : mUsbRegexs) {
+ if (s.matches(regex)) {
+ usbAvailable = true;
+ if (usbError == ConnectivityManager.TETHER_ERROR_NO_ERROR) {
+ usbError = cm.getLastTetherError(s);
+ }
+ }
+ }
+ }
+ for (Object o : tethered) {
+ String s = (String)o;
+ for (String regex : mUsbRegexs) {
+ if (s.matches(regex)) usbTethered = true;
+ }
+ }
+ for (Object o: errored) {
+ String s = (String)o;
+ for (String regex : mUsbRegexs) {
+ if (s.matches(regex)) usbErrored = true;
+ }
+ }
+
+ if (usbTethered) {
mUsbTether.setSummary(R.string.usb_tethering_active_subtext);
mUsbTether.setEnabled(true);
- } else if (isAvailable) {
- mUsbTether.setSummary(R.string.usb_tethering_available_subtext);
+ 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 (massStorageActive) {
+ 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);
}
}
@Override
public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
+ if (preference == mUsbTether) {
+ boolean newState = mUsbTether.isChecked();
+
+ ConnectivityManager cm =
+ (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
- if (preference == mEnableTetherNotice) {
- boolean newState = mEnableTetherNotice.isChecked();
- Settings.Secure.putInt(getContentResolver(),
- Settings.Secure.TETHER_NOTIFY, newState ? 1 : 0);
- return true;
+ if (newState) {
+ String[] available = cm.getTetherableIfaces();
+
+ String usbIface = findIface(available, mUsbRegexs);
+ if (usbIface == null) {
+ updateState();
+ return true;
+ }
+ if (cm.tether(usbIface) != ConnectivityManager.TETHER_ERROR_NO_ERROR) {
+ mUsbTether.setChecked(false);
+ mUsbTether.setSummary(R.string.usb_tethering_errored_subtext);
+ return true;
+ }
+ mUsbTether.setSummary("");
+ } else {
+ String [] tethered = cm.getTetheredIfaces();
+
+ String usbIface = findIface(tethered, mUsbRegexs);
+ if (usbIface == null) {
+ updateState();
+ return true;
+ }
+ if (cm.untether(usbIface) != ConnectivityManager.TETHER_ERROR_NO_ERROR) {
+ mUsbTether.setSummary(R.string.usb_tethering_errored_subtext);
+ return true;
+ }
+ mUsbTether.setSummary("");
+ }
+ } else if (preference == mTetherHelp) {
+
+ showDialog(DIALOG_TETHER_HELP);
}
return false;
}
+ private String findIface(String[] ifaces, String[] regexes) {
+ for (String iface : ifaces) {
+ for (String regex : regexes) {
+ if (iface.matches(regex)) {
+ return iface;
+ }
+ }
+ }
+ return null;
+ }
}